![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to i8042cmn.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / input / i8042prt|
Return to i8042cmn.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / input / i8042prt |
1.1 root 1:
2: /*++
3:
4: Copyright (c) 1990, 1991, 1992, 1993 Microsoft Corporation
5:
6: Module Name:
7:
8: i8042cmn.c
9:
10: Abstract:
11:
12: The common portions of the Intel i8042 port driver which
13: apply to both the keyboard and the auxiliary (PS/2 mouse) device.
14:
15: Environment:
16:
17: Kernel mode only.
18:
19: Notes:
20:
21: NOTES: (Future/outstanding issues)
22:
23: - Powerfail not implemented.
24:
25: - IOCTL_INTERNAL_KEYBOARD_DISCONNECT and IOCTL_INTERNAL_MOUSE_DISCONNECT
26: have not been implemented. They're not needed until the class
27: unload routine is implemented. Right now, we don't want to allow
28: either the keyboard or the mouse class driver to unload.
29:
30: - Consolidate duplicate code, where possible and appropriate.
31:
32: Revision History:
33:
34: --*/
35:
36: #include "stdarg.h"
37: #include "stdio.h"
38: #include "string.h"
39: #include "ntddk.h"
40: #include "i8042prt.h"
41: #include "i8042log.h"
42:
43: //
44: // Declare the global debug flag for this driver.
45: //
46:
47: #if DBG
48: ULONG i8042Debug = 0;
49: #endif
50:
51:
52: VOID
53: I8042CompletionDpc(
54: IN PKDPC Dpc,
55: IN PDEVICE_OBJECT DeviceObject,
56: IN PIRP Irp,
57: IN PVOID Context
58:
59: /*++
60:
61: Routine Description:
62:
63: This routine runs at DISPATCH_LEVEL IRQL to complete requests.
64: It is queued by the ISR routine.
65:
66: Note: Currently, only the keyboard ISR queues this routine.
67: Only the keyboard ISR handles both input and output to
68: the device. The mouse is input-only once it is initialized.
69:
70: Arguments:
71:
72: Dpc - Pointer to the DPC object.
73:
74: DeviceObject - Pointer to the device object.
75:
76: Irp - Not used.
77:
78: Context - Indicates type of error to log.
79:
80: Return Value:
81:
82: None.
83:
84: --*/
85:
86: )
87: {
88: PDEVICE_EXTENSION deviceExtension;
89: PIO_STACK_LOCATION irpSp;
90:
91: UNREFERENCED_PARAMETER(Dpc);
92: UNREFERENCED_PARAMETER(Context);
93:
94: I8xPrint((2, "I8042PRT-I8042CompletionDpc: enter\n"));
95:
96: //
97: // Get the device extension and current IRP.
98: //
99:
100: deviceExtension = DeviceObject->DeviceExtension;
101:
102: //
103: // Stop the command timer.
104: //
105:
106: KeCancelTimer(&deviceExtension->CommandTimer);
107:
108: //
109: // Get the current IRP.
110: //
111:
112: Irp = DeviceObject->CurrentIrp;
113: ASSERT(Irp != NULL);
114:
115: //
116: // Get a pointer to the current parameters for this request. The
117: // information is contained in the current stack location.
118: //
119:
120: irpSp = IoGetCurrentIrpStackLocation(Irp);
121:
122: //
123: // We know we're completing an internal device control request. Switch
124: // on IoControlCode.
125: //
126:
127: switch(irpSp->Parameters.DeviceIoControl.IoControlCode) {
128:
129: //
130: // Complete the keyboard set indicators request.
131: //
132:
133: case IOCTL_KEYBOARD_SET_INDICATORS:
134:
135: I8xPrint((
136: 2,
137: "I8042PRT-I8042CompletionDpc: keyboard set indicators updated\n"
138: ));
139:
140: //
141: // Update the current indicators flag in the device extension.
142: //
143:
144: deviceExtension->Configuration.KeyboardIndicators =
145: *(PKEYBOARD_INDICATOR_PARAMETERS)
146: Irp->AssociatedIrp.SystemBuffer;
147:
148: I8xPrint((
149: 2,
150: "I8042PRT-I8042CompletionDpc: new LED flags 0x%x\n",
151: deviceExtension->Configuration.KeyboardIndicators.LedFlags
152: ));
153:
154: break;
155:
156: //
157: // Complete the keyboard set typematic request.
158: //
159:
160: case IOCTL_KEYBOARD_SET_TYPEMATIC:
161:
162: I8xPrint((
163: 2,
164: "I8042PRT-I8042CompletionDpc: keyboard set typematic updated\n"
165: ));
166:
167: //
168: // Update the current typematic rate/delay in the device extension.
169: //
170:
171: deviceExtension->Configuration.KeyRepeatCurrent =
172: *(PKEYBOARD_TYPEMATIC_PARAMETERS)
173: Irp->AssociatedIrp.SystemBuffer;
174:
175: I8xPrint((
176: 2,
177: "I8042PRT-I8042CompletionDpc: new rate/delay 0x%x/%x\n",
178: deviceExtension->Configuration.KeyRepeatCurrent.Rate,
179: deviceExtension->Configuration.KeyRepeatCurrent.Delay
180: ));
181:
182: break;
183:
184: default:
185:
186: I8xPrint((2, "I8042PRT-I8042CompletionDpc: miscellaneous\n"));
187:
188: break;
189:
190: }
191:
192: //
193: // Set the completion status, start the next packet, and complete the
194: // request.
195: //
196:
197: Irp->IoStatus.Status = STATUS_SUCCESS;
198: IoStartNextPacket(DeviceObject, FALSE);
199: IoCompleteRequest (Irp, IO_KEYBOARD_INCREMENT);
200:
201: I8xPrint((2, "I8042PRT-I8042CompletionDpc: exit\n"));
202: }
203:
204: VOID
205: I8042ErrorLogDpc(
206: IN PKDPC Dpc,
207: IN PDEVICE_OBJECT DeviceObject,
208: IN PIRP Irp,
209: IN PVOID Context
210: )
211:
212: /*++
213:
214: Routine Description:
215:
216: This routine runs at DISPATCH_LEVEL IRQL to log errors that are
217: discovered at IRQL > DISPATCH_LEVEL (e.g., in the ISR routine or
218: in a routine that is executed via KeSynchronizeExecution). There
219: is not necessarily a current request associated with this condition.
220:
221: Arguments:
222:
223: Dpc - Pointer to the DPC object.
224:
225: DeviceObject - Pointer to the device object.
226:
227: Irp - Not used.
228:
229: Context - Indicates type of error to log.
230:
231: Return Value:
232:
233: None.
234:
235: --*/
236:
237: {
238: PDEVICE_EXTENSION deviceExtension;
239: PIO_ERROR_LOG_PACKET errorLogEntry;
240:
241: UNREFERENCED_PARAMETER(Dpc);
242: UNREFERENCED_PARAMETER(Irp);
243:
244: I8xPrint((2, "I8042PRT-I8042ErrorLogDpc: enter\n"));
245:
246: deviceExtension = DeviceObject->DeviceExtension;
247:
248: //
249: // Log an error packet.
250: //
251:
252: errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
253: DeviceObject,
254: sizeof(IO_ERROR_LOG_PACKET)
255: + (2 * sizeof(ULONG))
256: );
257: if (errorLogEntry != NULL) {
258:
259: errorLogEntry->DumpDataSize = 2 * sizeof(ULONG);
260: if ((ULONG) Context == I8042_KBD_BUFFER_OVERFLOW) {
261: errorLogEntry->UniqueErrorValue = I8042_ERROR_VALUE_BASE + 310;
262: errorLogEntry->DumpData[0] = sizeof(KEYBOARD_INPUT_DATA);
263: errorLogEntry->DumpData[1] =
264: deviceExtension->Configuration.KeyboardAttributes.InputDataQueueLength;
265: } else if ((ULONG) Context == I8042_MOU_BUFFER_OVERFLOW) {
266: errorLogEntry->UniqueErrorValue = I8042_ERROR_VALUE_BASE + 320;
267: errorLogEntry->DumpData[0] = sizeof(MOUSE_INPUT_DATA);
268: errorLogEntry->DumpData[1] =
269: deviceExtension->Configuration.MouseAttributes.InputDataQueueLength;
270: } else {
271: errorLogEntry->UniqueErrorValue = I8042_ERROR_VALUE_BASE + 330;
272: errorLogEntry->DumpData[0] = 0;
273: errorLogEntry->DumpData[1] = 0;
274: }
275:
276: errorLogEntry->ErrorCode = (ULONG) Context;
277: errorLogEntry->SequenceNumber = 0;
278: errorLogEntry->MajorFunctionCode = 0;
279: errorLogEntry->IoControlCode = 0;
280: errorLogEntry->RetryCount = 0;
281: errorLogEntry->FinalStatus = 0;
282:
283: IoWriteErrorLogEntry(errorLogEntry);
284: }
285:
286: I8xPrint((2, "I8042PRT-I8042ErrorLogDpc: exit\n"));
287:
288: }
289:
290: NTSTATUS
291: I8042Flush(
292: IN PDEVICE_OBJECT DeviceObject,
293: IN PIRP Irp
294: )
295: {
296: UNREFERENCED_PARAMETER(DeviceObject);
297: UNREFERENCED_PARAMETER(Irp);
298:
299: I8xPrint((2,"I8042PRT-I8042Flush: enter\n"));
300: I8xPrint((2,"I8042PRT-I8042Flush: exit\n"));
301:
302: return(STATUS_NOT_IMPLEMENTED);
303: }
304:
305: NTSTATUS
306: I8042InternalDeviceControl(
307: IN PDEVICE_OBJECT DeviceObject,
308: IN PIRP Irp
309: )
310:
311: /*++
312:
313: Routine Description:
314:
315: This routine is the dispatch routine for internal device control requests.
316:
317: Arguments:
318:
319: DeviceObject - Pointer to the device object.
320:
321: Irp - Pointer to the request packet.
322:
323: Return Value:
324:
325: Status is returned.
326:
327: --*/
328:
329: {
330:
331: PIO_STACK_LOCATION irpSp;
332: PDEVICE_EXTENSION deviceExtension;
333: NTSTATUS status;
334: I8042_INITIALIZE_DATA_CONTEXT initializeDataContext;
335: PVOID parameters;
336: PKEYBOARD_ATTRIBUTES keyboardAttributes;
337: ULONG sizeOfTranslation;
338:
339: I8xPrint((2,"I8042PRT-I8042InternalDeviceControl: enter\n"));
340:
341: //
342: // Get a pointer to the device extension.
343: //
344:
345: deviceExtension = DeviceObject->DeviceExtension;
346:
347: //
348: // Initialize the returned Information field.
349: //
350:
351: Irp->IoStatus.Information = 0;
352:
353: //
354: // Get a pointer to the current parameters for this request. The
355: // information is contained in the current stack location.
356: //
357:
358: irpSp = IoGetCurrentIrpStackLocation(Irp);
359:
360: //
361: // Case on the device control subfunction that is being performed by the
362: // requestor.
363: //
364:
365: switch (irpSp->Parameters.DeviceIoControl.IoControlCode) {
366:
367: //
368: // Connect a keyboard class device driver to the port driver.
369: //
370:
371: case IOCTL_INTERNAL_KEYBOARD_CONNECT:
372:
373: I8xPrint((
374: 2,
375: "I8042PRT-I8042InternalDeviceControl: keyboard connect\n"
376: ));
377:
378: //
379: // Only allow a connection if the keyboard hardware is present.
380: // Also, only allow one connection.
381: //
382: // FUTURE: Consider allowing multiple connections, just for
383: // the sake of generality? It really makes no sense for the
384: // i8042, though.
385: //
386:
387: if ((deviceExtension->HardwarePresent & KEYBOARD_HARDWARE_PRESENT)
388: != KEYBOARD_HARDWARE_PRESENT) {
389:
390: I8xPrint((
391: 2,
392: "I8042PRT-I8042InternalDeviceControl: error - hardware not present\n"
393: ));
394:
395: status = STATUS_NO_SUCH_DEVICE;
396: break;
397: } else
398: if (deviceExtension->KeyboardExtension.ConnectData.ClassService
399: != NULL) {
400:
401: I8xPrint((
402: 2,
403: "I8042PRT-I8042InternalDeviceControl: error - already connected\n"
404: ));
405:
406: status = STATUS_SHARING_VIOLATION;
407: break;
408:
409: } else
410: if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
411: sizeof(CONNECT_DATA)) {
412:
413: I8xPrint((
414: 2,
415: "I8042PRT-I8042InternalDeviceControl: error - invalid buffer length\n"
416: ));
417:
418: status = STATUS_INVALID_PARAMETER;
419: break;
420: }
421:
422: //
423: // Copy the connection parameters to the device extension.
424: //
425:
426: deviceExtension->KeyboardExtension.ConnectData =
427: *((PCONNECT_DATA) (irpSp->Parameters.DeviceIoControl.Type3InputBuffer));
428:
429: //
430: // Reinitialize the port input data queue.
431: //
432:
433: initializeDataContext.DeviceExtension = deviceExtension;
434: initializeDataContext.DeviceType = KeyboardDeviceType;
435:
436: KeSynchronizeExecution(
437: deviceExtension->KeyboardInterruptObject,
438: (PKSYNCHRONIZE_ROUTINE) I8xInitializeDataQueue,
439: (PVOID) &initializeDataContext
440: );
441:
442: //
443: // Set the completion status.
444: //
445:
446: status = STATUS_SUCCESS;
447: break;
448:
449: //
450: // Disconnect a keyboard class device driver from the port driver.
451: //
452: // NOTE: Not implemented.
453: //
454:
455: case IOCTL_INTERNAL_KEYBOARD_DISCONNECT:
456:
457: I8xPrint((
458: 2,
459: "I8042PRT-I8042InternalDeviceControl: keyboard disconnect\n"
460: ));
461:
462: //
463: // Perform a keyboard interrupt disable call.
464: //
465:
466: //
467: // Clear the connection parameters in the device extension.
468: // NOTE: Must synchronize this with the keyboard ISR.
469: //
470: //
471: //deviceExtension->KeyboardExtension.ConnectData.ClassDeviceObject =
472: // Null;
473: //deviceExtension->KeyboardExtension.ConnectData.ClassService =
474: // Null;
475:
476: //
477: // Set the completion status.
478: //
479:
480: status = STATUS_NOT_IMPLEMENTED;
481: break;
482:
483: //
484: // Connect a mouse class device driver to the port driver.
485: //
486:
487: case IOCTL_INTERNAL_MOUSE_CONNECT:
488:
489: I8xPrint((
490: 2,
491: "I8042PRT-I8042InternalDeviceControl: mouse connect\n"
492: ));
493:
494:
495: //
496: // Only allow a connection if the mouse hardware is present.
497: // Also, only allow one connection.
498: //
499: // FUTURE: Consider allowing multiple connections, just for
500: // the sake of generality? It really makes no sense for the
501: // i8042, though.
502: //
503:
504: if ((deviceExtension->HardwarePresent & MOUSE_HARDWARE_PRESENT)
505: != MOUSE_HARDWARE_PRESENT) {
506:
507: I8xPrint((
508: 2,
509: "I8042PRT-I8042InternalDeviceControl: error - hardware not present\n"
510: ));
511:
512: status = STATUS_NO_SUCH_DEVICE;
513: break;
514: } else
515: if (deviceExtension->MouseExtension.ConnectData.ClassService
516: != NULL) {
517:
518: I8xPrint((
519: 2,
520: "I8042PRT-I8042InternalDeviceControl: error - already connected\n"
521: ));
522:
523: status = STATUS_SHARING_VIOLATION;
524: break;
525:
526: } else
527: if (irpSp->Parameters.DeviceIoControl.InputBufferLength <
528: sizeof(CONNECT_DATA)) {
529:
530: I8xPrint((
531: 2,
532: "I8042PRT-I8042InternalDeviceControl: error - invalid buffer length\n"
533: ));
534:
535: status = STATUS_INVALID_PARAMETER;
536: break;
537: }
538:
539: //
540: // Copy the connection parameters to the device extension.
541: //
542:
543: deviceExtension->MouseExtension.ConnectData =
544: *((PCONNECT_DATA) (irpSp->Parameters.DeviceIoControl.Type3InputBuffer));
545:
546: //
547: // Reinitialize the port input data queue.
548: //
549:
550: initializeDataContext.DeviceExtension = deviceExtension;
551: initializeDataContext.DeviceType = MouseDeviceType;
552:
553: KeSynchronizeExecution(
554: deviceExtension->MouseInterruptObject,
555: (PKSYNCHRONIZE_ROUTINE) I8xInitializeDataQueue,
556: (PVOID) &initializeDataContext
557: );
558:
559: //
560: // Set the completion status.
561: //
562:
563: status = STATUS_SUCCESS;
564: break;
565:
566: //
567: // Disconnect a mouse class device driver from the port driver.
568: //
569: // NOTE: Not implemented.
570: //
571:
572: case IOCTL_INTERNAL_MOUSE_DISCONNECT:
573:
574: I8xPrint((
575: 2,
576: "I8042PRT-I8042InternalDeviceControl: mouse disconnect\n"
577: ));
578:
579: //
580: // Perform a mouse interrupt disable call.
581: //
582:
583: //
584: // Clear the connection parameters in the device extension.
585: // NOTE: Must synchronize this with the mouse ISR.
586: //
587: //
588: //deviceExtension->MouseExtension.ConnectData.ClassDeviceObject =
589: // Null;
590: //deviceExtension->MouseExtension.ConnectData.ClassService =
591: // Null;
592:
593: //
594: // Set the completion status.
595: //
596:
597: status = STATUS_NOT_IMPLEMENTED;
598: break;
599:
600: //
601: // Enable keyboard interrupts (mark the request pending and handle
602: // it in StartIo).
603: //
604:
605: case IOCTL_INTERNAL_KEYBOARD_ENABLE:
606:
607: I8xPrint((
608: 2,
609: "I8042PRT-I8042InternalDeviceControl: keyboard enable\n"
610: ));
611:
612: status = STATUS_PENDING;
613: break;
614:
615: //
616: // Disable keyboard interrupts (mark the request pending and handle
617: // it in StartIo).
618: //
619:
620: case IOCTL_INTERNAL_KEYBOARD_DISABLE:
621:
622: I8xPrint((
623: 2,
624: "I8042PRT-I8042InternalDeviceControl: keyboard disable\n"
625: ));
626:
627: status = STATUS_PENDING;
628: break;
629:
630: //
631: // Enable mouse interrupts (mark the request pending and handle
632: // it in StartIo).
633: //
634:
635: case IOCTL_INTERNAL_MOUSE_ENABLE:
636:
637: I8xPrint((
638: 2,
639: "I8042PRT-I8042InternalDeviceControl: mouse enable\n"
640: ));
641:
642: status = STATUS_PENDING;
643: break;
644:
645: //
646: // Disable mouse interrupts (mark the request pending and handle
647: // it in StartIo).
648: //
649:
650: case IOCTL_INTERNAL_MOUSE_DISABLE:
651:
652: I8xPrint((
653: 2,
654: "I8042PRT-I8042InternalDeviceControl: mouse disable\n"
655: ));
656:
657: status = STATUS_PENDING;
658: break;
659:
660: //
661: // Query the keyboard attributes. First check for adequate buffer
662: // length. Then, copy the keyboard attributes from the device
663: // extension to the output buffer.
664: //
665:
666: case IOCTL_KEYBOARD_QUERY_ATTRIBUTES:
667:
668: I8xPrint((
669: 2,
670: "I8042PRT-I8042InternalDeviceControl: keyboard query attributes\n"
671: ));
672:
673: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
674: sizeof(KEYBOARD_ATTRIBUTES)) {
675: status = STATUS_BUFFER_TOO_SMALL;
676: } else {
677:
678: //
679: // Copy the attributes from the DeviceExtension to the
680: // buffer.
681: //
682:
683: *(PKEYBOARD_ATTRIBUTES) Irp->AssociatedIrp.SystemBuffer =
684: deviceExtension->Configuration.KeyboardAttributes;
685:
686: Irp->IoStatus.Information = sizeof(KEYBOARD_ATTRIBUTES);
687: status = STATUS_SUCCESS;
688: }
689:
690: break;
691:
692: //
693: // Query the scan code to indicator-light mapping. Validate the
694: // parameters, and copy the indicator mapping information from
695: // the port device extension to the SystemBuffer.
696: //
697:
698: case IOCTL_KEYBOARD_QUERY_INDICATOR_TRANSLATION:
699:
700: I8xPrint((
701: 2,
702: "I8042PRT-I8042InternalDeviceControl: keyboard query indicator translation\n"
703: ));
704:
705: sizeOfTranslation = sizeof(KEYBOARD_INDICATOR_TRANSLATION)
706: + (sizeof(INDICATOR_LIST)
707: * (deviceExtension->Configuration.KeyboardAttributes.NumberOfIndicators - 1));
708:
709: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
710: sizeOfTranslation) {
711: status = STATUS_BUFFER_TOO_SMALL;
712: } else {
713:
714: //
715: // Copy the indicator mapping information to the system
716: // buffer.
717: //
718:
719: ((PKEYBOARD_INDICATOR_TRANSLATION)
720: Irp->AssociatedIrp.SystemBuffer)->NumberOfIndicatorKeys =
721: deviceExtension->Configuration.KeyboardAttributes.NumberOfIndicators;
722: RtlMoveMemory(
723: ((PKEYBOARD_INDICATOR_TRANSLATION)
724: Irp->AssociatedIrp.SystemBuffer)->IndicatorList,
725: (PCHAR) IndicatorList,
726: sizeOfTranslation
727: );
728:
729: Irp->IoStatus.Information = sizeOfTranslation;
730: status = STATUS_SUCCESS;
731: }
732:
733: break;
734:
735: //
736: // Query the keyboard indicators. Validate the parameters, and
737: // copy the indicator information from the port device extension to
738: // the SystemBuffer.
739: //
740:
741: case IOCTL_KEYBOARD_QUERY_INDICATORS:
742:
743:
744: I8xPrint((
745: 2,
746: "I8042PRT-I8042InternalDeviceControl: keyboard query indicators\n"
747: ));
748:
749: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
750: sizeof(KEYBOARD_INDICATOR_PARAMETERS)) {
751: status = STATUS_BUFFER_TOO_SMALL;
752: } else {
753:
754: //
755: // Don't bother to synchronize access to the DeviceExtension
756: // KeyboardIndicators field while copying it. We don't
757: // really care if another process is setting the LEDs via
758: // StartIo running on another processor.
759: //
760:
761: *(PKEYBOARD_INDICATOR_PARAMETERS)
762: Irp->AssociatedIrp.SystemBuffer =
763: deviceExtension->Configuration.KeyboardIndicators;
764: Irp->IoStatus.Information =
765: sizeof(KEYBOARD_INDICATOR_PARAMETERS);
766: status = STATUS_SUCCESS;
767: }
768:
769: break;
770:
771: //
772: // Set the keyboard indicators (validate the parameters, mark the
773: // request pending, and handle it in StartIo).
774: //
775:
776: case IOCTL_KEYBOARD_SET_INDICATORS:
777:
778: I8xPrint((
779: 2,
780: "I8042PRT-I8042InternalDeviceControl: keyboard set indicators\n"
781: ));
782:
783: if ((irpSp->Parameters.DeviceIoControl.InputBufferLength <
784: sizeof(KEYBOARD_INDICATOR_PARAMETERS)) ||
785: ((((PKEYBOARD_INDICATOR_PARAMETERS)
786: Irp->AssociatedIrp.SystemBuffer)->LedFlags
787: & ~(KEYBOARD_SCROLL_LOCK_ON
788: | KEYBOARD_NUM_LOCK_ON | KEYBOARD_CAPS_LOCK_ON)) != 0)) {
789: status = STATUS_INVALID_PARAMETER;
790: } else {
791: status = STATUS_PENDING;
792: }
793:
794: break;
795:
796: //
797: // Query the current keyboard typematic rate and delay. Validate
798: // the parameters, and copy the typematic information from the port
799: // device extension to the SystemBuffer.
800: //
801:
802: case IOCTL_KEYBOARD_QUERY_TYPEMATIC:
803:
804: I8xPrint((
805: 2,
806: "I8042PRT-I8042InternalDeviceControl: keyboard query typematic\n"
807: ));
808:
809: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
810: sizeof(KEYBOARD_TYPEMATIC_PARAMETERS)) {
811: status = STATUS_BUFFER_TOO_SMALL;
812: } else {
813:
814: //
815: // Don't bother to synchronize access to the DeviceExtension
816: // KeyRepeatCurrent field while copying it. We don't
817: // really care if another process is setting the typematic
818: // rate/delay via StartIo running on another processor.
819: //
820:
821: *(PKEYBOARD_TYPEMATIC_PARAMETERS)
822: Irp->AssociatedIrp.SystemBuffer =
823: deviceExtension->Configuration.KeyRepeatCurrent;
824: Irp->IoStatus.Information =
825: sizeof(KEYBOARD_TYPEMATIC_PARAMETERS);
826: status = STATUS_SUCCESS;
827: }
828:
829: break;
830:
831: //
832: // Set the keyboard typematic rate and delay (validate the parameters,
833: // mark the request pending, and handle it in StartIo).
834: //
835:
836: case IOCTL_KEYBOARD_SET_TYPEMATIC:
837:
838: I8xPrint((
839: 2,
840: "I8042PRT-I8042InternalDeviceControl: keyboard set typematic\n"
841: ));
842:
843: parameters = Irp->AssociatedIrp.SystemBuffer;
844: keyboardAttributes =
845: &deviceExtension->Configuration.KeyboardAttributes;
846:
847: if ((irpSp->Parameters.DeviceIoControl.InputBufferLength <
848: sizeof(KEYBOARD_TYPEMATIC_PARAMETERS)) ||
849: (((PKEYBOARD_TYPEMATIC_PARAMETERS) parameters)->Rate <
850: keyboardAttributes->KeyRepeatMinimum.Rate) ||
851: (((PKEYBOARD_TYPEMATIC_PARAMETERS) parameters)->Rate >
852: keyboardAttributes->KeyRepeatMaximum.Rate) ||
853: (((PKEYBOARD_TYPEMATIC_PARAMETERS) parameters)->Delay <
854: keyboardAttributes->KeyRepeatMinimum.Delay) ||
855: (((PKEYBOARD_TYPEMATIC_PARAMETERS) parameters)->Delay >
856: keyboardAttributes->KeyRepeatMaximum.Delay)) {
857: status = STATUS_INVALID_PARAMETER;
858: } else {
859: status = STATUS_PENDING;
860: }
861:
862: break;
863:
864: //
865: // Query the mouse attributes. First check for adequate buffer
866: // length. Then, copy the mouse attributes from the device
867: // extension to the output buffer.
868: //
869:
870: case IOCTL_MOUSE_QUERY_ATTRIBUTES:
871:
872: I8xPrint((
873: 2,
874: "I8042PRT-I8042InternalDeviceControl: mouse query attributes\n"
875: ));
876:
877: if (irpSp->Parameters.DeviceIoControl.OutputBufferLength <
878: sizeof(MOUSE_ATTRIBUTES)) {
879: status = STATUS_BUFFER_TOO_SMALL;
880: } else {
881:
882: //
883: // Copy the attributes from the DeviceExtension to the
884: // buffer.
885: //
886:
887: *(PMOUSE_ATTRIBUTES) Irp->AssociatedIrp.SystemBuffer =
888: deviceExtension->Configuration.MouseAttributes;
889:
890: Irp->IoStatus.Information = sizeof(MOUSE_ATTRIBUTES);
891: status = STATUS_SUCCESS;
892: }
893:
894: break;
895:
896: default:
897:
898: I8xPrint((
899: 2,
900: "I8042PRT-I8042InternalDeviceControl: INVALID REQUEST\n"
901: ));
902:
903: status = STATUS_INVALID_DEVICE_REQUEST;
904: break;
905: }
906:
907: Irp->IoStatus.Status = status;
908: if (status == STATUS_PENDING) {
909: IoMarkIrpPending(Irp);
910: IoStartPacket(DeviceObject, Irp, (PULONG)NULL, NULL);
911: } else {
912: IoCompleteRequest(Irp, IO_NO_INCREMENT);
913: }
914:
915: I8xPrint((2,"I8042PRT-I8042InternalDeviceControl: exit\n"));
916:
917: return(status);
918:
919: }
920:
921: NTSTATUS
922: I8042OpenCloseDispatch(
923: IN PDEVICE_OBJECT DeviceObject,
924: IN PIRP Irp
925: )
926:
927: /*++
928:
929: Routine Description:
930:
931: This is the dispatch routine for create/open and close requests.
932: These requests complete successfully.
933:
934: Arguments:
935:
936: DeviceObject - Pointer to the device object.
937:
938: Irp - Pointer to the request packet.
939:
940: Return Value:
941:
942: Status is returned.
943:
944: --*/
945:
946: {
947:
948: UNREFERENCED_PARAMETER(DeviceObject);
949:
950: I8xPrint((3,"I8042PRT-I8042OpenCloseDispatch: enter\n"));
951:
952: //
953: // Complete the request with successful status.
954: //
955:
956: Irp->IoStatus.Status = STATUS_SUCCESS;
957: Irp->IoStatus.Information = 0;
958: IoCompleteRequest(Irp, IO_NO_INCREMENT);
959:
960: I8xPrint((3,"I8042PRT-I8042OpenCloseDispatch: exit\n"));
961:
962: return(STATUS_SUCCESS);
963:
964: }
965:
966: VOID
967: I8042RetriesExceededDpc(
968: IN PKDPC Dpc,
969: IN PDEVICE_OBJECT DeviceObject,
970: IN PIRP Irp,
971: IN PVOID Context
972: )
973:
974: /*++
975:
976: Routine Description:
977:
978: This routine runs at DISPATCH_LEVEL IRQL to complete requests that
979: have exceeded the maximum number of retries. It is queued in the
980: keyboard ISR.
981:
982: Arguments:
983:
984: Dpc - Pointer to the DPC object.
985:
986: DeviceObject - Pointer to the device object.
987:
988: Irp - Pointer to the Irp.
989:
990: Context - Not used.
991:
992: Return Value:
993:
994: None.
995:
996: --*/
997:
998: {
999: PDEVICE_EXTENSION deviceExtension;
1000: PIO_ERROR_LOG_PACKET errorLogEntry;
1001: PIO_STACK_LOCATION irpSp;
1002:
1003: UNREFERENCED_PARAMETER(Dpc);
1004: UNREFERENCED_PARAMETER(Context);
1005:
1006: I8xPrint((2, "I8042PRT-I8042RetriesExceededDpc: enter\n"));
1007:
1008: deviceExtension = DeviceObject->DeviceExtension;
1009:
1010: //
1011: // Set the completion status.
1012: //
1013:
1014: Irp->IoStatus.Status = STATUS_IO_TIMEOUT;
1015:
1016: //
1017: // Log an error.
1018: //
1019:
1020: errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
1021: DeviceObject,
1022: sizeof(IO_ERROR_LOG_PACKET)
1023: + (3 * sizeof(ULONG))
1024: );
1025: if (errorLogEntry != NULL) {
1026:
1027: errorLogEntry->ErrorCode = I8042_RETRIES_EXCEEDED;
1028: errorLogEntry->DumpDataSize = 3 * sizeof(ULONG);
1029: errorLogEntry->SequenceNumber =
1030: deviceExtension->KeyboardExtension.SequenceNumber;
1031: irpSp = IoGetCurrentIrpStackLocation(Irp);
1032: errorLogEntry->MajorFunctionCode = irpSp->MajorFunction;
1033: errorLogEntry->IoControlCode =
1034: irpSp->Parameters.DeviceIoControl.IoControlCode;
1035: errorLogEntry->RetryCount =
1036: deviceExtension->KeyboardExtension.ResendCount;
1037: errorLogEntry->UniqueErrorValue = I8042_ERROR_VALUE_BASE + 210;
1038: errorLogEntry->FinalStatus = Irp->IoStatus.Status;
1039: errorLogEntry->DumpData[0] =
1040: deviceExtension->KeyboardExtension.CurrentOutput.State;
1041: errorLogEntry->DumpData[1] =
1042: deviceExtension->KeyboardExtension.CurrentOutput.FirstByte;
1043: errorLogEntry->DumpData[2] =
1044: deviceExtension->KeyboardExtension.CurrentOutput.LastByte;
1045:
1046: IoWriteErrorLogEntry(errorLogEntry);
1047: }
1048:
1049: //
1050: // Start the next packet and complete the request.
1051: //
1052:
1053: IoStartNextPacket(DeviceObject, FALSE);
1054: IoCompleteRequest (Irp, IO_KEYBOARD_INCREMENT);
1055:
1056: I8xPrint((2, "I8042PRT-I8042RetriesExceededDpc: exit\n"));
1057:
1058: }
1059:
1060: VOID
1061: I8042StartIo(
1062: IN PDEVICE_OBJECT DeviceObject,
1063: IN PIRP Irp
1064: )
1065:
1066: /*++
1067:
1068: Routine Description:
1069:
1070: This routine starts an I/O operation for the device.
1071:
1072: Arguments:
1073:
1074: DeviceObject - Pointer to the device object.
1075:
1076: Irp - Pointer to the request packet.
1077:
1078: Return Value:
1079:
1080: None.
1081:
1082: --*/
1083:
1084: {
1085: PDEVICE_EXTENSION deviceExtension;
1086: PIO_STACK_LOCATION irpSp;
1087: KEYBOARD_INITIATE_CONTEXT keyboardInitiateContext;
1088: LARGE_INTEGER deltaTime;
1089: INTERLOCKED_RESULT interlockedResult;
1090:
1091: I8xPrint((2, "I8042PRT-I8042StartIo: enter\n"));
1092:
1093: deviceExtension = DeviceObject->DeviceExtension;
1094:
1095: //
1096: // Bump the error log sequence number.
1097: //
1098:
1099: deviceExtension->KeyboardExtension.SequenceNumber += 1;
1100:
1101: //
1102: // Get a pointer to the current parameters for this request. The
1103: // information is contained in the current stack location.
1104: //
1105:
1106: irpSp = IoGetCurrentIrpStackLocation(Irp);
1107:
1108: //
1109: // We know we got here with an internal device control request. Switch
1110: // on IoControlCode.
1111: //
1112:
1113: switch(irpSp->Parameters.DeviceIoControl.IoControlCode) {
1114:
1115: //
1116: // Enable the keyboard device.
1117: //
1118:
1119: case IOCTL_INTERNAL_KEYBOARD_ENABLE:
1120:
1121: //
1122: // Enable keyboard by incrementing the KeyboardEnableCount
1123: // field. The keyboard ISR will start processing keyboard
1124: // interrupts when KeyboardEnableCount is non-zero. Note that
1125: // the keyboard device and its interrupts are *always* enabled
1126: // in the i8042 Controller Command Byte, following initialization.
1127: // Interrupts are ignored in the ISR, however, until the
1128: // KeyboardEnableCount is greater than zero (indicating that the
1129: // user has "enabled" the device).
1130: //
1131:
1132: interlockedResult = ExInterlockedIncrementLong(
1133: &deviceExtension->KeyboardEnableCount,
1134: &deviceExtension->SharedInterruptSpinLock
1135: );
1136:
1137: I8xPrint((
1138: 2,
1139: "I8042PRT-I8042StartIo: keyboard enable (count %d)\n",
1140: deviceExtension->KeyboardEnableCount
1141: ));
1142:
1143: Irp->IoStatus.Status = STATUS_SUCCESS;
1144:
1145: //
1146: // Complete the request.
1147: //
1148:
1149: IoStartNextPacket(DeviceObject, FALSE);
1150: IoCompleteRequest(Irp, IO_KEYBOARD_INCREMENT);
1151:
1152: break;
1153:
1154: //
1155: // Disable the keyboard device.
1156: //
1157:
1158: case IOCTL_INTERNAL_KEYBOARD_DISABLE:
1159:
1160: I8xPrint((2, "I8042PRT-I8042StartIo: keyboard disable"));
1161:
1162: if (deviceExtension->KeyboardEnableCount == 0) {
1163:
1164: //
1165: // Keyboard already disabled.
1166: //
1167:
1168: I8xPrint((2, " - error\n"));
1169:
1170: Irp->IoStatus.Status = STATUS_DEVICE_DATA_ERROR;
1171:
1172: } else {
1173:
1174: //
1175: // Disable keyboard by decrementing the KeyboardEnableCount
1176: // field. The keyboard ISR will ignore keyboard
1177: // interrupts when KeyboardEnableCount is zero.
1178: //
1179:
1180: interlockedResult =
1181: ExInterlockedDecrementLong(
1182: &deviceExtension->KeyboardEnableCount,
1183: &deviceExtension->SharedInterruptSpinLock
1184: );
1185:
1186: I8xPrint((
1187: 2,
1188: " (count %d)\n",
1189: deviceExtension->KeyboardEnableCount
1190: ));
1191:
1192: Irp->IoStatus.Status = STATUS_SUCCESS;
1193: }
1194:
1195: //
1196: // Complete the request.
1197: //
1198:
1199: IoStartNextPacket(DeviceObject, FALSE);
1200: IoCompleteRequest(Irp, IO_KEYBOARD_INCREMENT);
1201:
1202: break;
1203:
1204: //
1205: // Enable the mouse device.
1206: //
1207:
1208: case IOCTL_INTERNAL_MOUSE_ENABLE:
1209:
1210: //
1211: // Enable mouse by incrementing the MouseEnableCount
1212: // field. The mouse ISR will start processing mouse
1213: // interrupts when MouseEnableCount is non-zero. Note that
1214: // the mouse device and its interrupts are *always* enabled
1215: // in the i8042 Controller Command Byte, following initialization.
1216: // Interrupts are ignored in the ISR, however, until the
1217: // MouseEnableCount is greater than zero (indicating that the
1218: // user has "enabled" the device).
1219: //
1220:
1221:
1222: interlockedResult = ExInterlockedIncrementLong(
1223: &deviceExtension->MouseEnableCount,
1224: &deviceExtension->SharedInterruptSpinLock
1225: );
1226:
1227:
1228: I8xPrint((
1229: 2,
1230: "I8042PRT-I8042StartIo: mouse enable (count %d)\n",
1231: deviceExtension->MouseEnableCount
1232: ));
1233:
1234: Irp->IoStatus.Status = STATUS_SUCCESS;
1235:
1236: //
1237: // Complete the request.
1238: //
1239:
1240: IoStartNextPacket(DeviceObject, FALSE);
1241: IoCompleteRequest(Irp, IO_MOUSE_INCREMENT);
1242:
1243: break;
1244:
1245: //
1246: // Disable the mouse device.
1247: //
1248:
1249: case IOCTL_INTERNAL_MOUSE_DISABLE:
1250:
1251: I8xPrint((2, "I8042PRT-I8042StartIo: mouse disable"));
1252:
1253: if (deviceExtension->MouseEnableCount == 0) {
1254:
1255: //
1256: // Mouse already disabled.
1257: //
1258:
1259: I8xPrint((2, " - error\n"));
1260:
1261: Irp->IoStatus.Status = STATUS_DEVICE_DATA_ERROR;
1262:
1263: } else {
1264:
1265: //
1266: // Disable mouse by decrementing the MouseEnableCount
1267: // field. The mouse ISR will ignore keyboard
1268: // interrupts when MouseEnableCount is zero.
1269: //
1270:
1271: interlockedResult =
1272: ExInterlockedDecrementLong(
1273: &deviceExtension->MouseEnableCount,
1274: &deviceExtension->SharedInterruptSpinLock
1275: );
1276:
1277: I8xPrint((
1278: 2,
1279: " (count %d)\n",
1280: deviceExtension->MouseEnableCount
1281: ));
1282:
1283: Irp->IoStatus.Status = STATUS_SUCCESS;
1284: }
1285:
1286: //
1287: // Complete the request.
1288: //
1289:
1290: IoStartNextPacket(DeviceObject, FALSE);
1291: IoCompleteRequest(Irp, IO_MOUSE_INCREMENT);
1292:
1293: break;
1294:
1295: //
1296: // Set the keyboard indicators to the desired state.
1297: //
1298:
1299: case IOCTL_KEYBOARD_SET_INDICATORS:
1300:
1301: I8xPrint((2, "I8042PRT-I8042StartIo: keyboard set indicators\n"));
1302:
1303: //
1304: // Set up the context structure for the InitiateIo wrapper.
1305: //
1306:
1307: keyboardInitiateContext.DeviceObject = DeviceObject;
1308: keyboardInitiateContext.FirstByte = SET_KEYBOARD_INDICATORS;
1309: keyboardInitiateContext.LastByte =
1310: (UCHAR) ((PKEYBOARD_INDICATOR_PARAMETERS)
1311: Irp->AssociatedIrp.SystemBuffer)->LedFlags;
1312:
1313: //
1314: // Call the InitiateIo wrapper synchronously. The wrapper
1315: // stores the context parameters in the device extension,
1316: // and then initiates the I/O operation, all synchronized
1317: // with the keyboard ISR.
1318: //
1319:
1320: KeSynchronizeExecution(
1321: deviceExtension->KeyboardInterruptObject,
1322: (PKSYNCHRONIZE_ROUTINE) I8xKeyboardInitiateWrapper,
1323: (PVOID) &keyboardInitiateContext
1324: );
1325:
1326: //
1327: // Start the 1-second command timer. InitiateIo changed
1328: // the TimerCount already.
1329: //
1330:
1331: deltaTime.LowPart = (ULONG)(-10 * 1000 * 1000);
1332: deltaTime.HighPart = -1;
1333:
1334: (VOID) KeSetTimer(
1335: &deviceExtension->CommandTimer,
1336: deltaTime,
1337: &deviceExtension->TimeOutDpc
1338: );
1339:
1340: break;
1341:
1342: //
1343: // Set the keyboard typematic rate and delay.
1344: //
1345:
1346: case IOCTL_KEYBOARD_SET_TYPEMATIC:
1347:
1348: I8xPrint((2, "I8042PRT-I8042StartIo: keyboard set typematic\n"));
1349:
1350: //
1351: // Set up the context structure for the InitiateIo wrapper.
1352: //
1353:
1354: keyboardInitiateContext.DeviceObject = DeviceObject;
1355: keyboardInitiateContext.FirstByte = SET_KEYBOARD_TYPEMATIC;
1356: keyboardInitiateContext.LastByte =
1357: I8xConvertTypematicParameters(
1358: ((PKEYBOARD_TYPEMATIC_PARAMETERS)
1359: Irp->AssociatedIrp.SystemBuffer)->Rate,
1360: ((PKEYBOARD_TYPEMATIC_PARAMETERS)
1361: Irp->AssociatedIrp.SystemBuffer)->Delay
1362: );
1363:
1364: //
1365: // Call the InitiateIo wrapper synchronously. The wrapper
1366: // stores the context parameters in the device extension,
1367: // and then initiates the I/O operation, all synchronized
1368: // with the keyboard ISR.
1369: //
1370:
1371: KeSynchronizeExecution(
1372: deviceExtension->KeyboardInterruptObject,
1373: (PKSYNCHRONIZE_ROUTINE) I8xKeyboardInitiateWrapper,
1374: (PVOID) &keyboardInitiateContext
1375: );
1376:
1377: //
1378: // Start the 1-second command timer. InitiateIo changed
1379: // the TimerCount already.
1380: //
1381:
1382: deltaTime.LowPart = (ULONG)(-10 * 1000 * 1000);
1383: deltaTime.HighPart = -1;
1384:
1385: (VOID) KeSetTimer(
1386: &deviceExtension->CommandTimer,
1387: deltaTime,
1388: &deviceExtension->TimeOutDpc
1389: );
1390:
1391: break;
1392:
1393: default:
1394:
1395: I8xPrint((2, "I8042PRT-I8042StartIo: INVALID REQUEST\n"));
1396:
1397: //
1398: // Log an internal error. Note that we're calling the
1399: // error log DPC routine directly, rather than duplicating
1400: // code.
1401: //
1402:
1403: I8042ErrorLogDpc(
1404: (PKDPC) NULL,
1405: DeviceObject,
1406: Irp,
1407: (PVOID) (ULONG) I8042_INVALID_STARTIO_REQUEST
1408: );
1409:
1410: ASSERT(FALSE);
1411: break;
1412: }
1413:
1414: I8xPrint((2, "I8042PRT-I8042StartIo: exit\n"));
1415:
1416: return;
1417: }
1418:
1419: VOID
1420: I8042TimeOutDpc(
1421: IN PKDPC Dpc,
1422: IN PDEVICE_OBJECT DeviceObject,
1423: IN PVOID SystemContext1,
1424: IN PVOID SystemContext2
1425: )
1426:
1427: /*++
1428:
1429: Routine Description:
1430:
1431: This is the driver's command timeout routine. It is called when the
1432: command timer fires.
1433:
1434: Arguments:
1435:
1436: Dpc - Not Used.
1437:
1438: DeviceObject - Pointer to the device object.
1439:
1440: SystemContext1 - Not Used.
1441:
1442: SystemContext2 - Not Used.
1443:
1444: Return Value:
1445:
1446: None. As a side-effect, the timeout counter is updated and an error
1447: is logged.
1448:
1449: --*/
1450:
1451: {
1452: PDEVICE_EXTENSION deviceExtension;
1453: KIRQL cancelIrql;
1454: TIMER_CONTEXT timerContext;
1455: PIRP irp;
1456: PIO_ERROR_LOG_PACKET errorLogEntry;
1457: PIO_STACK_LOCATION irpSp;
1458: LARGE_INTEGER deltaTime;
1459:
1460: I8xPrint((3, "I8042PRT-I8042TimeOutDpc: enter\n"));
1461:
1462: //
1463: // Get the device extension.
1464: //
1465:
1466: deviceExtension = DeviceObject->DeviceExtension;
1467:
1468: //
1469: // Acquire the cancel spinlock, verify that the CurrentIrp has not been
1470: // cancelled (i.e., CurrentIrp != NULL), set the cancel routine to NULL,
1471: // and release the cancel spinlock.
1472: //
1473:
1474: IoAcquireCancelSpinLock(&cancelIrql);
1475: irp = DeviceObject->CurrentIrp;
1476: if (irp == NULL) {
1477: IoReleaseCancelSpinLock(cancelIrql);
1478: return;
1479: }
1480: IoSetCancelRoutine(irp, NULL);
1481: IoReleaseCancelSpinLock(cancelIrql);
1482:
1483: //
1484: // If the TimerCounter == 0 on entry to this routine, the last packet
1485: // timed out and was completed. We just decrement TimerCounter
1486: // (synchronously) to indicate that we're no longer timing.
1487: //
1488: // If the TimerCounter indicates no timeout (I8042_ASYNC_NO_TIMEOUT)
1489: // on entry to this routine, there is no command being timed.
1490: //
1491:
1492: timerContext.DeviceObject = DeviceObject;
1493: timerContext.TimerCounter = &deviceExtension->TimerCount;
1494:
1495: KeSynchronizeExecution(
1496: deviceExtension->KeyboardInterruptObject,
1497: (PKSYNCHRONIZE_ROUTINE) I8xDecrementTimer,
1498: &timerContext
1499: );
1500:
1501: if (timerContext.NewTimerCount == 0) {
1502:
1503: //
1504: // Set up the IO Status Block prior to completing the request.
1505: //
1506:
1507: DeviceObject->CurrentIrp->IoStatus.Information = 0;
1508: DeviceObject->CurrentIrp->IoStatus.Status = STATUS_IO_TIMEOUT;
1509:
1510: //
1511: // Log a timeout error.
1512: //
1513:
1514: errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
1515: DeviceObject,
1516: sizeof(IO_ERROR_LOG_PACKET)
1517: + (3 * sizeof(ULONG))
1518: );
1519:
1520: if (errorLogEntry != NULL) {
1521:
1522: errorLogEntry->ErrorCode = I8042_TIMEOUT;
1523: errorLogEntry->DumpDataSize = 3 * sizeof(ULONG);
1524: errorLogEntry->SequenceNumber =
1525: deviceExtension->KeyboardExtension.SequenceNumber;
1526: irpSp = IoGetCurrentIrpStackLocation(irp);
1527: errorLogEntry->MajorFunctionCode = irpSp->MajorFunction;
1528: errorLogEntry->IoControlCode =
1529: irpSp->Parameters.DeviceIoControl.IoControlCode;
1530: errorLogEntry->RetryCount =
1531: deviceExtension->KeyboardExtension.ResendCount;
1532: errorLogEntry->UniqueErrorValue = 90;
1533: errorLogEntry->FinalStatus = STATUS_IO_TIMEOUT;
1534: errorLogEntry->DumpData[0] =
1535: deviceExtension->KeyboardExtension.CurrentOutput.State;
1536: errorLogEntry->DumpData[1] =
1537: deviceExtension->KeyboardExtension.CurrentOutput.FirstByte;
1538: errorLogEntry->DumpData[2] =
1539: deviceExtension->KeyboardExtension.CurrentOutput.LastByte;
1540:
1541: IoWriteErrorLogEntry(errorLogEntry);
1542: }
1543:
1544: //
1545: // Start the next packet and complete the request.
1546: //
1547:
1548: IoStartNextPacket(DeviceObject, FALSE);
1549: IoCompleteRequest(irp, IO_KEYBOARD_INCREMENT);
1550:
1551: } else {
1552:
1553: //
1554: // Restart the command timer. Once started, the timer stops only
1555: // when the TimerCount goes to zero (indicating that the command
1556: // has timed out) or when explicitly cancelled in the completion
1557: // DPC (indicating that the command has successfully completed).
1558: //
1559:
1560: deltaTime.LowPart = (ULONG)(-10 * 1000 * 1000);
1561: deltaTime.HighPart = -1;
1562:
1563: (VOID) KeSetTimer(
1564: &deviceExtension->CommandTimer,
1565: deltaTime,
1566: &deviceExtension->TimeOutDpc
1567: );
1568: }
1569:
1570: I8xPrint((3, "I8042PRT-I8042TimeOutDpc: exit\n"));
1571: }
1572:
1573: #if DBG
1574: VOID
1575: I8xDebugPrint(
1576: ULONG DebugPrintLevel,
1577: PCCHAR DebugMessage,
1578: ...
1579: )
1580:
1581: /*++
1582:
1583: Routine Description:
1584:
1585: Debug print routine.
1586:
1587: Arguments:
1588:
1589: Debug print level between 0 and 3, with 3 being the most verbose.
1590:
1591: Return Value:
1592:
1593: None.
1594:
1595: --*/
1596:
1597: {
1598: va_list ap;
1599:
1600: va_start(ap, DebugMessage);
1601:
1602: if (DebugPrintLevel <= i8042Debug) {
1603:
1604: char buffer[128];
1605:
1606: (VOID) vsprintf(buffer, DebugMessage, ap);
1607:
1608: DbgPrint(buffer);
1609: }
1610:
1611: va_end(ap);
1612:
1613: }
1614: #endif
1615:
1616:
1617: VOID
1618: I8xDecrementTimer(
1619: IN PTIMER_CONTEXT Context
1620: )
1621:
1622: /*++
1623:
1624: Routine Description:
1625:
1626: This routine decrements the timeout counter. It is called from
1627: I8042TimeOutDpc.
1628:
1629: Arguments:
1630:
1631: Context - Points to the context structure containing a pointer
1632: to the device object and a pointer to the timeout counter.
1633:
1634: Return Value:
1635:
1636: None. As a side-effect, the timeout counter is updated.
1637:
1638: --*/
1639:
1640: {
1641: PDEVICE_OBJECT deviceObject;
1642: PDEVICE_EXTENSION deviceExtension;
1643:
1644: deviceObject = Context->DeviceObject;
1645: deviceExtension = deviceObject->DeviceExtension;
1646:
1647: //
1648: // Decrement the timeout counter.
1649: //
1650:
1651: if (*(Context->TimerCounter) != I8042_ASYNC_NO_TIMEOUT)
1652: (*(Context->TimerCounter))--;
1653:
1654: //
1655: // Return the decremented timer count in NewTimerCount. The
1656: // TimerCounter itself could change between the time this KeSynch'ed
1657: // routine returns to the TimeOutDpc, and the time the TimeOutDpc
1658: // looks at the value. The TimeOutDpc will use NewTimerCount.
1659: //
1660:
1661: Context->NewTimerCount = *(Context->TimerCounter);
1662:
1663: //
1664: // Reset the state and the resend count, if the timeout counter goes to 0.
1665: //
1666:
1667: if (*(Context->TimerCounter) == 0) {
1668: deviceExtension->KeyboardExtension.CurrentOutput.State
1669: = Idle;
1670: deviceExtension->KeyboardExtension.ResendCount = 0;
1671: }
1672:
1673: }
1674:
1675: VOID
1676: I8xDpcVariableOperation(
1677: IN PVOID Context
1678: )
1679:
1680: /*++
1681:
1682: Routine Description:
1683:
1684: This routine is called synchronously by the ISR DPC to perform an
1685: operation on the InterlockedDpcVariable. The operations that can be
1686: performed include increment, decrement, write, and read. The ISR
1687: itself reads and writes the InterlockedDpcVariable without calling this
1688: routine.
1689:
1690: Arguments:
1691:
1692: Context - Pointer to a structure containing the address of the variable
1693: to be operated on, the operation to perform, and the address at
1694: which to copy the resulting value of the variable (the latter is also
1695: used to pass in the value to write to the variable, on a write
1696: operation).
1697:
1698: Return Value:
1699:
1700: None.
1701:
1702: --*/
1703:
1704: {
1705: PVARIABLE_OPERATION_CONTEXT operationContext = Context;
1706:
1707: I8xPrint((3,"I8042PRT-I8xDpcVariableOperation: enter\n"));
1708: I8xPrint((
1709: 3,
1710: "\tPerforming %s at 0x%x (current value 0x%x)\n",
1711: (operationContext->Operation == IncrementOperation)? "increment":
1712: (operationContext->Operation == DecrementOperation)? "decrement":
1713: (operationContext->Operation == WriteOperation)? "write":
1714: (operationContext->Operation == ReadOperation)? "read":"",
1715: operationContext->VariableAddress,
1716: *(operationContext->VariableAddress)
1717: ));
1718:
1719: //
1720: // Perform the specified operation at the specified address.
1721: //
1722:
1723: switch(operationContext->Operation) {
1724: case IncrementOperation:
1725: *(operationContext->VariableAddress) += 1;
1726: break;
1727: case DecrementOperation:
1728: *(operationContext->VariableAddress) -= 1;
1729: break;
1730: case ReadOperation:
1731: break;
1732: case WriteOperation:
1733: I8xPrint((
1734: 3,
1735: "\tWriting 0x%x\n",
1736: *(operationContext->NewValue)
1737: ));
1738: *(operationContext->VariableAddress) =
1739: *(operationContext->NewValue);
1740: break;
1741: default:
1742: ASSERT(FALSE);
1743: break;
1744: }
1745:
1746: *(operationContext->NewValue) = *(operationContext->VariableAddress);
1747:
1748: I8xPrint((
1749: 3,
1750: "I8042PRT-I8xDpcVariableOperation: exit with value 0x%x\n",
1751: *(operationContext->NewValue)
1752: ));
1753: }
1754:
1755: VOID
1756: I8xGetDataQueuePointer(
1757: IN PVOID Context
1758: )
1759:
1760: /*++
1761:
1762: Routine Description:
1763:
1764: This routine is called synchronously to get the current DataIn and DataOut
1765: pointers for the port InputData queue.
1766:
1767: Arguments:
1768:
1769: Context - Pointer to a structure containing the device extension,
1770: device type, address at which to store the current DataIn pointer,
1771: and the address at which to store the current DataOut pointer.
1772:
1773: Return Value:
1774:
1775: None.
1776:
1777: --*/
1778:
1779: {
1780: PDEVICE_EXTENSION deviceExtension;
1781: CCHAR deviceType;
1782:
1783: I8xPrint((3,"I8042PRT-I8xGetDataQueuePointer: enter\n"));
1784:
1785: //
1786: // Get address of device extension.
1787: //
1788:
1789: deviceExtension = (PDEVICE_EXTENSION)
1790: ((PGET_DATA_POINTER_CONTEXT) Context)->DeviceExtension;
1791: deviceType = (CCHAR) ((PGET_DATA_POINTER_CONTEXT) Context)->DeviceType;
1792:
1793: //
1794: // Get the DataIn and DataOut pointers for the indicated device.
1795: //
1796:
1797: if (deviceType == KeyboardDeviceType) {
1798: I8xPrint((3,"I8042PRT-I8xGetDataQueuePointer: keyboard\n"));
1799: I8xPrint((
1800: 3,
1801: "I8042PRT-I8xGetDataQueuePointer: DataIn 0x%x, DataOut 0x%x\n",
1802: deviceExtension->KeyboardExtension.DataIn,
1803: deviceExtension->KeyboardExtension.DataOut
1804: ));
1805: ((PGET_DATA_POINTER_CONTEXT) Context)->DataIn =
1806: deviceExtension->KeyboardExtension.DataIn;
1807: ((PGET_DATA_POINTER_CONTEXT) Context)->DataOut =
1808: deviceExtension->KeyboardExtension.DataOut;
1809: ((PGET_DATA_POINTER_CONTEXT) Context)->InputCount =
1810: deviceExtension->KeyboardExtension.InputCount;
1811: } else if (deviceType == MouseDeviceType) {
1812: I8xPrint((3,"I8042PRT-I8xGetDataQueuePointer: mouse\n"));
1813: I8xPrint((
1814: 3,
1815: "I8042PRT-I8xGetDataQueuePointer: DataIn 0x%x, DataOut 0x%x\n",
1816: deviceExtension->MouseExtension.DataIn,
1817: deviceExtension->MouseExtension.DataOut
1818: ));
1819: ((PGET_DATA_POINTER_CONTEXT) Context)->DataIn =
1820: deviceExtension->MouseExtension.DataIn;
1821: ((PGET_DATA_POINTER_CONTEXT) Context)->DataOut =
1822: deviceExtension->MouseExtension.DataOut;
1823: ((PGET_DATA_POINTER_CONTEXT) Context)->InputCount =
1824: deviceExtension->MouseExtension.InputCount;
1825: } else {
1826: ASSERT(FALSE);
1827: }
1828:
1829: I8xPrint((3,"I8042PRT-I8xGetDataQueuePointer: exit\n"));
1830: }
1831:
1832: VOID
1833: I8xInitializeDataQueue (
1834: IN PVOID Context
1835: )
1836:
1837: /*++
1838:
1839: Routine Description:
1840:
1841: This routine initializes the input data queue for the indicated device.
1842: This routine is called via KeSynchronization, except when called from
1843: the initialization routine.
1844:
1845: Arguments:
1846:
1847: Context - Pointer to a structure containing the device extension and
1848: the device type.
1849:
1850: Return Value:
1851:
1852: None.
1853:
1854: --*/
1855:
1856: {
1857:
1858: PDEVICE_EXTENSION deviceExtension;
1859: CCHAR deviceType;
1860:
1861: I8xPrint((3,"I8042PRT-I8xInitializeDataQueue: enter\n"));
1862:
1863: //
1864: // Get address of device extension.
1865: //
1866:
1867: deviceExtension = (PDEVICE_EXTENSION)
1868: ((PI8042_INITIALIZE_DATA_CONTEXT) Context)->DeviceExtension;
1869: deviceType = (CCHAR) ((PI8042_INITIALIZE_DATA_CONTEXT) Context)->DeviceType;
1870:
1871: //
1872: // Initialize the input data queue for the indicated device.
1873: //
1874:
1875: if (deviceType == KeyboardDeviceType) {
1876: deviceExtension->KeyboardExtension.InputCount = 0;
1877: deviceExtension->KeyboardExtension.DataIn =
1878: deviceExtension->KeyboardExtension.InputData;
1879: deviceExtension->KeyboardExtension.DataOut =
1880: deviceExtension->KeyboardExtension.InputData;
1881: deviceExtension->KeyboardExtension.OkayToLogOverflow = TRUE;
1882: I8xPrint((3,"I8042PRT-I8xInitializeDataQueue: keyboard\n"));
1883: } else if (deviceType == MouseDeviceType) {
1884: deviceExtension->MouseExtension.InputCount = 0;
1885: deviceExtension->MouseExtension.DataIn =
1886: deviceExtension->MouseExtension.InputData;
1887: deviceExtension->MouseExtension.DataOut =
1888: deviceExtension->MouseExtension.InputData;
1889: deviceExtension->MouseExtension.OkayToLogOverflow = TRUE;
1890: I8xPrint((3,"I8042PRT-I8xInitializeDataQueue: mouse\n"));
1891: } else {
1892: ASSERT(FALSE);
1893: }
1894:
1895: I8xPrint((3,"I8042PRT-I8xInitializeDataQueue: exit\n"));
1896:
1897: }
1898:
1899: VOID
1900: I8xLogError(
1901: IN PDEVICE_OBJECT DeviceObject,
1902: IN NTSTATUS ErrorCode,
1903: IN ULONG UniqueErrorValue,
1904: IN NTSTATUS FinalStatus,
1905: IN PULONG DumpData,
1906: IN ULONG DumpCount
1907: )
1908:
1909: /*++
1910:
1911: Routine Description:
1912:
1913: This routine contains common code to write an error log entry. It is
1914: called from other routines, especially I8xInitializeKeyboard, to avoid
1915: duplication of code. Note that some routines continue to have their
1916: own error logging code (especially in the case where the error logging
1917: can be localized and/or the routine has more data because there is
1918: and IRP).
1919:
1920: Arguments:
1921:
1922: DeviceObject - Pointer to the device object.
1923:
1924: ErrorCode - The error code for the error log packet.
1925:
1926: UniqueErrorValue - The unique error value for the error log packet.
1927:
1928: FinalStatus - The final status of the operation for the error log packet.
1929:
1930: DumpData - Pointer to an array of dump data for the error log packet.
1931:
1932: DumpCount - The number of entries in the dump data array.
1933:
1934:
1935: Return Value:
1936:
1937: None.
1938:
1939: --*/
1940:
1941: {
1942: PIO_ERROR_LOG_PACKET errorLogEntry;
1943: ULONG i;
1944:
1945: errorLogEntry = (PIO_ERROR_LOG_PACKET) IoAllocateErrorLogEntry(
1946: DeviceObject,
1947: (UCHAR)
1948: (sizeof(IO_ERROR_LOG_PACKET)
1949: + (DumpCount * sizeof(ULONG)))
1950: );
1951:
1952: if (errorLogEntry != NULL) {
1953:
1954: errorLogEntry->ErrorCode = ErrorCode;
1955: errorLogEntry->DumpDataSize = (USHORT) (DumpCount * sizeof(ULONG));
1956: errorLogEntry->SequenceNumber = 0;
1957: errorLogEntry->MajorFunctionCode = 0;
1958: errorLogEntry->IoControlCode = 0;
1959: errorLogEntry->RetryCount = 0;
1960: errorLogEntry->UniqueErrorValue = UniqueErrorValue;
1961: errorLogEntry->FinalStatus = FinalStatus;
1962: for (i = 0; i < DumpCount; i++)
1963: errorLogEntry->DumpData[i] = DumpData[i];
1964:
1965: IoWriteErrorLogEntry(errorLogEntry);
1966: }
1967: }
1968:
1969: VOID
1970: I8xSetDataQueuePointer(
1971: IN PVOID Context
1972: )
1973:
1974: /*++
1975:
1976: Routine Description:
1977:
1978: This routine is called synchronously to set the DataOut pointer
1979: and InputCount for the port InputData queue.
1980:
1981: Arguments:
1982:
1983: Context - Pointer to a structure containing the device extension,
1984: device type, and the new DataOut value for the port InputData queue.
1985:
1986: Return Value:
1987:
1988: None.
1989:
1990: --*/
1991:
1992: {
1993: PDEVICE_EXTENSION deviceExtension;
1994: CCHAR deviceType;
1995:
1996: I8xPrint((3,"I8042PRT-I8xSetDataQueuePointer: enter\n"));
1997:
1998: //
1999: // Get address of device extension.
2000: //
2001:
2002: deviceExtension = (PDEVICE_EXTENSION)
2003: ((PSET_DATA_POINTER_CONTEXT) Context)->DeviceExtension;
2004: deviceType = (CCHAR) ((PSET_DATA_POINTER_CONTEXT) Context)->DeviceType;
2005:
2006: //
2007: // Set the DataOut pointer for the indicated device.
2008: //
2009:
2010: if (deviceType == KeyboardDeviceType) {
2011: I8xPrint((
2012: 3,
2013: "I8042PRT-I8xSetDataQueuePointer: old keyboard DataOut 0x%x, InputCount %d\n",
2014: deviceExtension->KeyboardExtension.DataOut,
2015: deviceExtension->KeyboardExtension.InputCount
2016: ));
2017: deviceExtension->KeyboardExtension.DataOut =
2018: ((PSET_DATA_POINTER_CONTEXT) Context)->DataOut;
2019: deviceExtension->KeyboardExtension.InputCount -=
2020: ((PSET_DATA_POINTER_CONTEXT) Context)->InputCount;
2021: if (deviceExtension->KeyboardExtension.InputCount == 0) {
2022:
2023: //
2024: // Reset the flag that determines whether it is time to log
2025: // queue overflow errors. We don't want to log errors too often.
2026: // Instead, log an error on the first overflow that occurs after
2027: // the ring buffer has been emptied, and then stop logging errors
2028: // until it gets cleared out and overflows again.
2029: //
2030:
2031: I8xPrint((
2032: 1,
2033: "I8042PRT-I8xSetDataQueuePointer: Okay to log keyboard overflow\n"
2034: ));
2035: deviceExtension->KeyboardExtension.OkayToLogOverflow = TRUE;
2036: }
2037: I8xPrint((
2038: 3,
2039: "I8042PRT-I8xSetDataQueuePointer: new keyboard DataOut 0x%x, InputCount %d\n",
2040: deviceExtension->KeyboardExtension.DataOut,
2041: deviceExtension->KeyboardExtension.InputCount
2042: ));
2043: } else if (deviceType == MouseDeviceType) {
2044: I8xPrint((
2045: 3,
2046: "I8042PRT-I8xSetDataQueuePointer: old mouse DataOut 0x%x, InputCount %d\n",
2047: deviceExtension->MouseExtension.DataOut,
2048: deviceExtension->MouseExtension.InputCount
2049: ));
2050: deviceExtension->MouseExtension.DataOut =
2051: ((PSET_DATA_POINTER_CONTEXT) Context)->DataOut;
2052: deviceExtension->MouseExtension.InputCount -=
2053: ((PSET_DATA_POINTER_CONTEXT) Context)->InputCount;
2054: if (deviceExtension->MouseExtension.InputCount == 0) {
2055:
2056: //
2057: // Reset the flag that determines whether it is time to log
2058: // queue overflow errors. We don't want to log errors too often.
2059: // Instead, log an error on the first overflow that occurs after
2060: // the ring buffer has been emptied, and then stop logging errors
2061: // until it gets cleared out and overflows again.
2062: //
2063:
2064: I8xPrint((
2065: 1,
2066: "I8042PRT-I8xSetDataQueuePointer: Okay to log mouse overflow\n"
2067: ));
2068: deviceExtension->MouseExtension.OkayToLogOverflow = TRUE;
2069: }
2070: I8xPrint((
2071: 3,
2072: "I8042PRT-I8xSetDataQueuePointer: new mouse DataOut 0x%x, InputCount %d\n",
2073: deviceExtension->MouseExtension.DataOut,
2074: deviceExtension->MouseExtension.InputCount
2075: ));
2076: } else {
2077: ASSERT(FALSE);
2078: }
2079:
2080: I8xPrint((3,"I8042PRT-I8xSetDataQueuePointer: exit\n"));
2081: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.