![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to moudep.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 moudep.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: moudep.c
9:
10: Abstract:
11:
12: The initialization and hardware-dependent portions of
13: the Intel i8042 port driver which are specific to
14: the auxiliary (PS/2 mouse) device.
15:
16: Environment:
17:
18: Kernel mode only.
19:
20: Notes:
21:
22: NOTES: (Future/outstanding issues)
23:
24: - Powerfail not implemented.
25:
26: - Consolidate duplicate code, where possible and appropriate.
27:
28: Revision History:
29:
30: --*/
31:
32: #include "stdarg.h"
33: #include "stdio.h"
34: #include "string.h"
35: #include "ntddk.h"
36: #include "i8042prt.h"
37: #include "i8042log.h"
38:
39: //
40: // Use the alloc_text pragma to specify the driver initialization routines
41: // (they can be paged out).
42: //
43:
44: #ifdef ALLOC_PRAGMA
45: #pragma alloc_text(init,I8xMouseConfiguration)
46: #pragma alloc_text(init,I8xMousePeripheralCallout)
47: #pragma alloc_text(init,I8xInitializeMouse)
48: #endif
49:
50:
51: BOOLEAN
52: I8042MouseInterruptService(
53: IN PKINTERRUPT Interrupt,
54: IN PVOID Context
55: )
56:
57: /*++
58:
59: Routine Description:
60:
61: This is the interrupt service routine for the mouse device.
62:
63: Arguments:
64:
65: Interrupt - A pointer to the interrupt object for this interrupt.
66:
67: Context - A pointer to the device object.
68:
69: Return Value:
70:
71: Returns TRUE if the interrupt was expected (and therefore processed);
72: otherwise, FALSE is returned.
73:
74: --*/
75:
76: {
77: PDEVICE_EXTENSION deviceExtension;
78: PDEVICE_OBJECT deviceObject;
79: LARGE_INTEGER tickDelta, newTick;
80: UCHAR previousButtons;
81: UCHAR previousSignAndOverflow;
82: UCHAR byte;
83:
84: UNREFERENCED_PARAMETER(Interrupt);
85:
86: I8xPrint((2, "I8042PRT-I8042MouseInterruptService: enter\n"));
87:
88: deviceObject = (PDEVICE_OBJECT) Context;
89: deviceExtension = (PDEVICE_EXTENSION) deviceObject->DeviceExtension;
90:
91: //
92: // Verify that this device really interrupted. Check the status
93: // register. The Output Buffer Full bit should be set, and the
94: // Auxiliary Device Output Buffer Full bit should be set.
95: //
96:
97: if ((I8X_GET_STATUS_BYTE(deviceExtension->DeviceRegisters[CommandPort])
98: & (OUTPUT_BUFFER_FULL|MOUSE_OUTPUT_BUFFER_FULL))
99: != (OUTPUT_BUFFER_FULL|MOUSE_OUTPUT_BUFFER_FULL)) {
100:
101: //
102: // Stall and then try again. The Olivetti MIPS machine
103: // sometimes gets a mouse interrupt before the status
104: // register is set.
105: //
106:
107: KeStallExecutionProcessor(10);
108: if ((I8X_GET_STATUS_BYTE(deviceExtension->DeviceRegisters[CommandPort])
109: & (OUTPUT_BUFFER_FULL|MOUSE_OUTPUT_BUFFER_FULL))
110: != (OUTPUT_BUFFER_FULL|MOUSE_OUTPUT_BUFFER_FULL)) {
111:
112: //
113: // Not our interrupt.
114: //
115:
116: I8xPrint((
117: 1,
118: "I8042PRT-I8042MouseInterruptService: not our interrupt!\n"
119: ));
120: return(FALSE);
121: }
122: }
123:
124: //
125: // Read the byte from the i8042 data port.
126: //
127:
128: I8xGetByteAsynchronous(
129: (CCHAR) MouseDeviceType,
130: deviceExtension,
131: &byte
132: );
133:
134: I8xPrint((
135: 3,
136: "I8042PRT-I8042MouseInterruptService: byte 0x%x\n",
137: byte
138: ));
139:
140: //
141: // Take the appropriate action, depending on the current state.
142: // When the state is Idle, we expect to receive mouse button
143: // data. When the state is XMovement, we expect to receive mouse
144: // motion in the X direction data. When the state is YMovement,
145: // we expect to receive mouse motion in the Y direction data. Once
146: // the Y motion data has been received, the data is queued to the
147: // mouse InputData queue, the mouse ISR DPC is requested, and the
148: // state returns to Idle.
149: //
150:
151: KeQueryTickCount(&newTick);
152: tickDelta = RtlLargeIntegerSubtract(
153: newTick,
154: deviceExtension->MouseExtension.PreviousTick
155: );
156:
157: if ((deviceExtension->MouseExtension.InputState != MouseIdle)
158: && (deviceExtension->MouseExtension.InputState != MouseExpectingACK)
159: && ((tickDelta.LowPart >= deviceExtension->MouseExtension.SynchTickCount)
160: || (tickDelta.HighPart != 0))) {
161:
162: //
163: // It has been a long time since we got a byte of
164: // the data packet. Assume that we are now receiving
165: // the first byte of a new packet, and discard any
166: // partially received packet.
167: //
168: // N.B. We assume that SynchTickCount is ULONG, and avoid
169: // a LARGE_INTEGER compare with tickDelta...
170: //
171:
172: I8xPrint((
173: 1,
174: "I8042PRT-I8042MouseInterruptService: State was %d, synching\n",
175: deviceExtension->MouseExtension.InputState
176: ));
177:
178: deviceExtension->MouseExtension.InputState = MouseIdle;
179: }
180:
181: deviceExtension->MouseExtension.PreviousTick = newTick;
182:
183: switch(deviceExtension->MouseExtension.InputState) {
184:
185: //
186: // The mouse interrupted with a status byte. The status byte
187: // contains information on the mouse button state along with
188: // the sign and overflow bits for the (yet-to-be-received)
189: // X and Y motion bytes.
190: //
191:
192: case MouseIdle:
193:
194: I8xPrint((
195: 3,
196: "I8042PRT-I8042MouseInterruptService: mouse status byte\n"
197: ));
198:
199: //
200: // Update CurrentInput with button transition data.
201: // I.e., set a button up/down bit in the Buttons field if
202: // the state of a given button has changed since we
203: // received the last packet.
204: //
205:
206: previousButtons =
207: deviceExtension->MouseExtension.PreviousButtons;
208:
209: deviceExtension->MouseExtension.CurrentInput.Buttons = 0;
210:
211: if ((!(previousButtons & LEFT_BUTTON_DOWN))
212: && (byte & LEFT_BUTTON_DOWN)) {
213: deviceExtension->MouseExtension.CurrentInput.Buttons |=
214: MOUSE_LEFT_BUTTON_DOWN;
215: } else
216: if ((previousButtons & LEFT_BUTTON_DOWN)
217: && !(byte & LEFT_BUTTON_DOWN)) {
218: deviceExtension->MouseExtension.CurrentInput.Buttons |=
219: MOUSE_LEFT_BUTTON_UP;
220: }
221: if ((!(previousButtons & RIGHT_BUTTON_DOWN))
222: && (byte & RIGHT_BUTTON_DOWN)) {
223: deviceExtension->MouseExtension.CurrentInput.Buttons |=
224: MOUSE_RIGHT_BUTTON_DOWN;
225: } else
226: if ((previousButtons & RIGHT_BUTTON_DOWN)
227: && !(byte & RIGHT_BUTTON_DOWN)) {
228: deviceExtension->MouseExtension.CurrentInput.Buttons |=
229: MOUSE_RIGHT_BUTTON_UP;
230: }
231: if ((!(previousButtons & MIDDLE_BUTTON_DOWN))
232: && (byte & MIDDLE_BUTTON_DOWN)) {
233: deviceExtension->MouseExtension.CurrentInput.Buttons |=
234: MOUSE_MIDDLE_BUTTON_DOWN;
235: } else
236: if ((previousButtons & MIDDLE_BUTTON_DOWN)
237: && !(byte & MIDDLE_BUTTON_DOWN)) {
238: deviceExtension->MouseExtension.CurrentInput.Buttons |=
239: MOUSE_MIDDLE_BUTTON_UP;
240: }
241:
242: //
243: // Save the button state for comparison the next time around.
244: //
245:
246: deviceExtension->MouseExtension.PreviousButtons =
247: byte & (RIGHT_BUTTON_DOWN|MIDDLE_BUTTON_DOWN|LEFT_BUTTON_DOWN);
248:
249: //
250: // Save the sign and overflow information from the current byte.
251: //
252:
253: deviceExtension->MouseExtension.CurrentSignAndOverflow =
254: (UCHAR) (byte & MOUSE_SIGN_OVERFLOW_MASK);
255:
256: //
257: // Update to the next state.
258: //
259:
260: deviceExtension->MouseExtension.InputState = XMovement;
261:
262: break;
263:
264: //
265: // The mouse interrupted with the X motion byte. Apply
266: // the sign and overflow bits from the mouse status byte received
267: // previously. Attempt to correct for bogus changes in sign
268: // that occur with large, rapid mouse movements.
269: //
270:
271: case XMovement:
272:
273: I8xPrint((
274: 3,
275: "I8042PRT-I8042MouseInterruptService: mouse LastX byte\n"
276: ));
277:
278: //
279: // Update CurrentInput with the X motion data.
280: //
281:
282: if (deviceExtension->MouseExtension.CurrentSignAndOverflow
283: & X_OVERFLOW) {
284:
285: //
286: // Handle overflow in the X direction. If the previous
287: // mouse movement overflowed too, ensure that the current
288: // overflow is in the same direction (i.e., that the sign
289: // is the same as it was for the previous event). We do this
290: // to correct for hardware problems -- it should not be possible
291: // to overflow in one direction and then immediately overflow
292: // in the opposite direction.
293: //
294:
295: previousSignAndOverflow =
296: deviceExtension->MouseExtension.PreviousSignAndOverflow;
297: if (previousSignAndOverflow & X_OVERFLOW) {
298: if ((previousSignAndOverflow & X_DATA_SIGN) !=
299: (deviceExtension->MouseExtension.CurrentSignAndOverflow
300: & X_DATA_SIGN)) {
301: deviceExtension->MouseExtension.CurrentSignAndOverflow
302: ^= X_DATA_SIGN;
303: }
304: }
305:
306: if (deviceExtension->MouseExtension.CurrentSignAndOverflow &
307: X_DATA_SIGN)
308: deviceExtension->MouseExtension.CurrentInput.LastX =
309: (LONG) MOUSE_MAXIMUM_NEGATIVE_DELTA;
310: else
311: deviceExtension->MouseExtension.CurrentInput.LastX =
312: (LONG) MOUSE_MAXIMUM_POSITIVE_DELTA;
313:
314: } else {
315:
316: //
317: // No overflow. Just store the data, correcting for the
318: // sign if necessary.
319: //
320:
321: deviceExtension->MouseExtension.CurrentInput.LastX =
322: (ULONG) byte;
323: if (deviceExtension->MouseExtension.CurrentSignAndOverflow &
324: X_DATA_SIGN)
325: deviceExtension->MouseExtension.CurrentInput.LastX |=
326: MOUSE_MAXIMUM_NEGATIVE_DELTA;
327: }
328:
329: //
330: // Update to the next state.
331: //
332:
333: deviceExtension->MouseExtension.InputState = YMovement;
334:
335: break;
336:
337: //
338: // The mouse interrupted with the Y motion byte. Apply
339: // the sign and overflow bits from the mouse status byte received
340: // previously. [Attempt to correct for bogus changes in sign
341: // that occur with large, rapid mouse movements.] Write the
342: // data to the mouse InputData queue, and queue the mouse ISR DPC
343: // to complete the interrupt processing.
344: //
345:
346: case YMovement:
347:
348: I8xPrint((
349: 3,
350: "I8042PRT-I8042MouseInterruptService: mouse LastY byte\n"
351: ));
352:
353: //
354: // Update CurrentInput with the Y motion data.
355: //
356:
357: if (deviceExtension->MouseExtension.CurrentSignAndOverflow
358: & Y_OVERFLOW) {
359:
360: //
361: // Handle overflow in the Y direction. If the previous
362: // mouse movement overflowed too, ensure that the current
363: // overflow is in the same direction (i.e., that the sign
364: // is the same as it was for the previous event). We do this
365: // to correct for hardware problems -- it should not be possible
366: // to overflow in one direction and then immediately overflow
367: // in the opposite direction.
368: //
369:
370: previousSignAndOverflow =
371: deviceExtension->MouseExtension.PreviousSignAndOverflow;
372: if (previousSignAndOverflow & Y_OVERFLOW) {
373: if ((previousSignAndOverflow & Y_DATA_SIGN) !=
374: (deviceExtension->MouseExtension.CurrentSignAndOverflow
375: & Y_DATA_SIGN)) {
376: deviceExtension->MouseExtension.CurrentSignAndOverflow
377: ^= Y_DATA_SIGN;
378: }
379: }
380:
381: if (deviceExtension->MouseExtension.CurrentSignAndOverflow &
382: Y_DATA_SIGN)
383: deviceExtension->MouseExtension.CurrentInput.LastY =
384: (LONG) MOUSE_MAXIMUM_POSITIVE_DELTA;
385: else
386: deviceExtension->MouseExtension.CurrentInput.LastY =
387: (LONG) MOUSE_MAXIMUM_NEGATIVE_DELTA;
388:
389: } else {
390:
391: //
392: // No overflow. Just store the data, correcting for the
393: // sign if necessary.
394: //
395:
396: deviceExtension->MouseExtension.CurrentInput.LastY =
397: (ULONG) byte;
398: if (deviceExtension->MouseExtension.CurrentSignAndOverflow &
399: Y_DATA_SIGN)
400: deviceExtension->MouseExtension.CurrentInput.LastY |=
401: MOUSE_MAXIMUM_NEGATIVE_DELTA;
402:
403: //
404: // Negate the LastY value (the hardware reports positive
405: // motion in the direction that we consider negative).
406: //
407:
408: deviceExtension->MouseExtension.CurrentInput.LastY =
409: -deviceExtension->MouseExtension.CurrentInput.LastY;
410:
411: }
412:
413: //
414: // Update our notion of the previous sign and overflow bits for
415: // the start of the next mouse input sequence.
416: //
417:
418: deviceExtension->MouseExtension.PreviousSignAndOverflow =
419: deviceExtension->MouseExtension.CurrentSignAndOverflow;
420:
421: //
422: // If the mouse is enabled, add the data to the InputData queue
423: // and queue the ISR DPC. One might wonder why we bother to
424: // do all this processing of the mouse packet, only to toss it
425: // away (i.e., not queue it) at this point. The answer is that
426: // this mouse provides no data to allow the driver to determine
427: // when the first byte of a packet is received -- if the driver
428: // doesn't process all interrupts from the start, there is no
429: // way to keep MouseExtension.InputState in synch with hardware
430: // reality.
431: //
432:
433: if (deviceExtension->MouseEnableCount) {
434: deviceExtension->MouseExtension.CurrentInput.UnitId =
435: deviceExtension->MouseExtension.UnitId;
436: if (!I8xWriteDataToMouseQueue(
437: &deviceExtension->MouseExtension,
438: &deviceExtension->MouseExtension.CurrentInput
439: )) {
440:
441: //
442: // InputData queue overflowed.
443: //
444: // Queue a DPC to log an overrun error.
445: //
446:
447: I8xPrint((
448: 1,
449: "I8042PRT-I8042MouseInterruptService: queue overflow\n"
450: ));
451:
452: if (deviceExtension->MouseExtension.OkayToLogOverflow) {
453: KeInsertQueueDpc(
454: &deviceExtension->ErrorLogDpc,
455: (PIRP) NULL,
456: (PVOID) (ULONG) I8042_MOU_BUFFER_OVERFLOW
457: );
458: deviceExtension->MouseExtension.OkayToLogOverflow =
459: FALSE;
460: }
461:
462: } else if (deviceExtension->DpcInterlockMouse >= 0) {
463:
464: //
465: // The ISR DPC is already executing. Tell the ISR DPC it has
466: // more work to do by incrementing DpcInterlockMouse.
467: //
468:
469: deviceExtension->DpcInterlockMouse += 1;
470:
471: } else {
472:
473: //
474: // Queue the ISR DPC.
475: //
476:
477: KeInsertQueueDpc(
478: &deviceExtension->MouseIsrDpc,
479: deviceObject->CurrentIrp,
480: NULL
481: );
482: }
483:
484: }
485:
486: //
487: // Reset the state.
488: //
489:
490: deviceExtension->MouseExtension.InputState = MouseIdle;
491:
492: break;
493:
494: case MouseExpectingACK:
495:
496: //
497: // This is a special case. We hit this on one of the very
498: // first mouse interrupts following the IoConnectInterrupt.
499: // The interrupt is caused when we enable mouse transmissions
500: // via I8xMouseEnableTransmission() -- the hardware returns
501: // an ACK. Just toss this byte away, and set the input state
502: // to coincide with the start of a new mouse data packet.
503: //
504:
505: I8xPrint((
506: 1,
507: "I8042PRT-I8042MouseInterruptService: expecting ACK (0x%x), got 0x%x\n",
508: (ULONG) ACKNOWLEDGE,
509: (ULONG) byte
510: ));
511:
512: if (byte == (UCHAR) ACKNOWLEDGE) {
513: deviceExtension->MouseExtension.InputState = MouseIdle;
514: } else if (byte == (UCHAR) RESEND) {
515:
516: //
517: // Resend the "Enable Mouse Transmission" sequence.
518: //
519: // NOTE: This is a hack for the Olivetti MIPS machine,
520: // which sends a resend response if a key is held down
521: // while we're attempting the I8xMouseEnableTransmission.
522: //
523:
524: I8xPutByteAsynchronous(
525: (CCHAR) CommandPort,
526: deviceExtension,
527: (UCHAR) I8042_WRITE_TO_AUXILIARY_DEVICE
528: );
529:
530: I8xPutByteAsynchronous(
531: (CCHAR) DataPort,
532: deviceExtension,
533: (UCHAR) ENABLE_MOUSE_TRANSMISSION
534: );
535: }
536:
537: break;
538:
539: default:
540:
541: I8xPrint((
542: 3,
543: "I8042PRT-I8042MouseInterruptService: INVALID STATE\n"
544: ));
545:
546: //
547: // Queue a DPC to log an internal driver error.
548: //
549:
550: KeInsertQueueDpc(
551: &deviceExtension->ErrorLogDpc,
552: (PIRP) NULL,
553: (PVOID) (ULONG) I8042_INVALID_ISR_STATE
554: );
555:
556: ASSERT(FALSE);
557: break;
558:
559: }
560:
561: I8xPrint((2, "I8042PRT-I8042MouseInterruptService: exit\n"));
562:
563: return(TRUE);
564: }
565:
566: NTSTATUS
567: I8xInitializeMouse(
568: IN PDEVICE_OBJECT DeviceObject
569: )
570:
571: /*++
572:
573: Routine Description:
574:
575: This routine initializes the i8042 mouse hardware. It is called
576: only at initialization, and does not synchronize access to the hardware.
577:
578: Arguments:
579:
580: DeviceObject - Pointer to the device object.
581:
582: Return Value:
583:
584: Returns status.
585:
586: --*/
587:
588: {
589: NTSTATUS status;
590: PDEVICE_EXTENSION deviceExtension;
591: UCHAR byte;
592: ULONG i;
593: PIO_ERROR_LOG_PACKET errorLogEntry;
594: ULONG uniqueErrorValue;
595: NTSTATUS errorCode = STATUS_SUCCESS;
596: ULONG dumpCount = 0;
597:
598: #define DUMP_COUNT 4
599: ULONG dumpData[DUMP_COUNT];
600:
601: I8xPrint((2, "I8042PRT-I8xInitializeMouse: enter\n"));
602:
603: for (i = 0; i < DUMP_COUNT; i++)
604: dumpData[i] = 0;
605:
606: //
607: // Get the device extension.
608: //
609:
610: deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
611:
612: //
613: // Reset the mouse. Send a Write To Auxiliary Device command to the
614: // 8042 controller. Then send the Reset Mouse command to the mouse
615: // through the 8042 data register. Expect to get back an ACK, followed
616: // by a completion code and the ID code (0x00).
617: //
618:
619: status = I8xPutBytePolled(
620: (CCHAR) DataPort,
621: WAIT_FOR_ACKNOWLEDGE,
622: (CCHAR) MouseDeviceType,
623: deviceExtension,
624: (UCHAR) MOUSE_RESET
625: );
626: if (!NT_SUCCESS(status)) {
627: I8xPrint((
628: 1,
629: "I8042PRT-I8xInitializeMouse: failed mouse reset, status 0x%x\n",
630: status
631: ));
632:
633: //
634: // Set up error log info.
635: //
636:
637: errorCode = I8042_MOU_RESET_COMMAND_FAILED;
638: uniqueErrorValue = I8042_ERROR_VALUE_BASE + 415;
639: dumpData[0] = KBDMOU_COULD_NOT_SEND_PARAM;
640: dumpData[1] = DataPort;
641: dumpData[2] = I8042_WRITE_TO_AUXILIARY_DEVICE;
642: dumpData[3] = MOUSE_RESET;
643: dumpCount = 4;
644:
645: goto I8xInitializeMouseExit;
646: }
647:
648: //
649: // Get the mouse reset responses. The first response should be a
650: // MOUSE_COMPLETE. The second response should be the mouse ID.
651: // Note that it is usually necessary to stall a long time to get the
652: // mouse reset/self-test to work. The stall value was determined by
653: // experimentation.
654: //
655: //
656:
657: for (i = 0; i < 11200; i++) {
658:
659: status = I8xGetBytePolled(
660: (CCHAR) ControllerDeviceType,
661: deviceExtension,
662: &byte
663: );
664:
665: if (NT_SUCCESS(status) && (byte == (UCHAR) MOUSE_COMPLETE)) {
666:
667: //
668: // The reset completed successfully.
669: //
670:
671: break;
672:
673:
674: } else {
675:
676: //
677: // Stall, and then try again to get a response from
678: // the reset.
679: //
680:
681: if (status == STATUS_IO_TIMEOUT) {
682:
683: //
684: // Stall, and then try again to get a response from
685: // the reset.
686: //
687:
688: KeStallExecutionProcessor(50);
689:
690: } else {
691:
692: break;
693:
694: }
695: }
696: }
697:
698: if (!NT_SUCCESS(status)) {
699: I8xPrint((
700: 1,
701: "I8042PRT-I8xInitializeMouse: failed reset response 1, status 0x%x, byte 0x%x\n",
702: status,
703: byte
704: ));
705:
706: //
707: // Set up error log info.
708: //
709:
710: errorCode = I8042_MOU_RESET_RESPONSE_FAILED;
711: uniqueErrorValue = I8042_ERROR_VALUE_BASE + 420;
712: dumpData[0] = KBDMOU_INCORRECT_RESPONSE;
713: dumpData[1] = ControllerDeviceType;
714: dumpData[2] = MOUSE_COMPLETE;
715: dumpData[3] = byte;
716: dumpCount = 4;
717:
718: goto I8xInitializeMouseExit;
719: }
720:
721: status = I8xGetBytePolled(
722: (CCHAR) ControllerDeviceType,
723: deviceExtension,
724: &byte
725: );
726:
727: if ((!NT_SUCCESS(status)) || (byte != MOUSE_ID_BYTE)) {
728: I8xPrint((
729: 1,
730: "I8042PRT-I8xInitializeMouse: failed reset response 2, status 0x%x, byte 0x%x\n",
731: status,
732: byte
733: ));
734:
735: //
736: // Set up error log info.
737: //
738:
739: errorCode = I8042_MOU_RESET_RESPONSE_FAILED;
740: uniqueErrorValue = I8042_ERROR_VALUE_BASE + 425;
741: dumpData[0] = KBDMOU_INCORRECT_RESPONSE;
742: dumpData[1] = ControllerDeviceType;
743: dumpData[2] = MOUSE_ID_BYTE;
744: dumpData[3] = byte;
745: dumpCount = 4;
746:
747: goto I8xInitializeMouseExit;
748: }
749:
750: //
751: // Set mouse sampling rate. Send a Write To Auxiliary Device command
752: // to the 8042 controller. Then send the Set Mouse Sampling Rate
753: // command to the mouse through the 8042 data register,
754: // followed by its parameter.
755: //
756:
757: status = I8xPutBytePolled(
758: (CCHAR) DataPort,
759: WAIT_FOR_ACKNOWLEDGE,
760: (CCHAR) MouseDeviceType,
761: deviceExtension,
762: (UCHAR) SET_MOUSE_SAMPLING_RATE
763: );
764: if (!NT_SUCCESS(status)) {
765: I8xPrint((
766: 1,
767: "I8042PRT-I8xInitializeMouse: failed write set sample rate, status 0x%x\n",
768: status
769: ));
770:
771: //
772: // Set up error log info.
773: //
774:
775: errorCode = I8042_SET_SAMPLE_RATE_FAILED;
776: uniqueErrorValue = I8042_ERROR_VALUE_BASE + 435;
777: dumpData[0] = KBDMOU_COULD_NOT_SEND_PARAM;
778: dumpData[1] = DataPort;
779: dumpData[2] = I8042_WRITE_TO_AUXILIARY_DEVICE;
780: dumpData[3] = SET_MOUSE_SAMPLING_RATE;
781: dumpCount = 4;
782:
783: goto I8xInitializeMouseExit;
784: }
785:
786: status = I8xPutBytePolled(
787: (CCHAR) DataPort,
788: WAIT_FOR_ACKNOWLEDGE,
789: (CCHAR) MouseDeviceType,
790: deviceExtension,
791: (UCHAR) MOUSE_SAMPLE_RATE
792: );
793: if (!NT_SUCCESS(status)) {
794: I8xPrint((
795: 1,
796: "I8042PRT-I8xInitializeMouse: failed write sample rate, status 0x%x\n",
797: status
798: ));
799:
800: //
801: // Set up error log info.
802: //
803:
804: errorCode = I8042_SET_SAMPLE_RATE_FAILED;
805: uniqueErrorValue = I8042_ERROR_VALUE_BASE + 445;
806: dumpData[0] = KBDMOU_COULD_NOT_SEND_PARAM;
807: dumpData[1] = DataPort;
808: dumpData[2] = I8042_WRITE_TO_AUXILIARY_DEVICE;
809: dumpData[3] = MOUSE_SAMPLE_RATE;
810: dumpCount = 4;
811:
812: goto I8xInitializeMouseExit;
813: }
814:
815: //
816: // Set the mouse resolution. Send a Write To Auxiliary Device command
817: // to the 8042 controller. Then send the Set Mouse Resolution
818: // command to the mouse through the 8042 data register,
819: // followed by its parameter.
820: //
821:
822: status = I8xPutBytePolled(
823: (CCHAR) DataPort,
824: WAIT_FOR_ACKNOWLEDGE,
825: (CCHAR) MouseDeviceType,
826: deviceExtension,
827: (UCHAR) SET_MOUSE_RESOLUTION
828: );
829: if (!NT_SUCCESS(status)) {
830: I8xPrint((
831: 1,
832: "I8042PRT-I8xInitializeMouse: failed write set resolution, status 0x%x\n",
833: status
834: ));
835:
836: //
837: // Set up error log info.
838: //
839:
840: errorCode = I8042_SET_RESOLUTION_FAILED;
841: uniqueErrorValue = I8042_ERROR_VALUE_BASE + 455;
842: dumpData[0] = KBDMOU_COULD_NOT_SEND_PARAM;
843: dumpData[1] = DataPort;
844: dumpData[2] = I8042_WRITE_TO_AUXILIARY_DEVICE;
845: dumpData[3] = SET_MOUSE_RESOLUTION;
846: dumpCount = 4;
847:
848: goto I8xInitializeMouseExit;
849: }
850:
851: status = I8xPutBytePolled(
852: (CCHAR) DataPort,
853: WAIT_FOR_ACKNOWLEDGE,
854: (CCHAR) MouseDeviceType,
855: deviceExtension,
856: (UCHAR) deviceExtension->Configuration.MouseResolution
857: );
858: if (!NT_SUCCESS(status)) {
859: I8xPrint((
860: 1,
861: "I8042PRT-I8xInitializeMouse: failed set mouse resolution, status 0x%x\n",
862: status
863: ));
864:
865: //
866: // Set up error log info.
867: //
868:
869: errorCode = I8042_SET_RESOLUTION_FAILED;
870: uniqueErrorValue = I8042_ERROR_VALUE_BASE + 465;
871: dumpData[0] = KBDMOU_COULD_NOT_SEND_PARAM;
872: dumpData[1] = DataPort;
873: dumpData[2] = I8042_WRITE_TO_AUXILIARY_DEVICE;
874: dumpData[3] = deviceExtension->Configuration.MouseResolution;
875: dumpCount = 4;
876:
877: goto I8xInitializeMouseExit;
878: }
879:
880: I8xInitializeMouseExit:
881:
882: if (!NT_SUCCESS(status)) {
883:
884: //
885: // The mouse initialization failed. Log an error.
886: //
887:
888: if (errorCode != STATUS_SUCCESS) {
889: errorLogEntry = (PIO_ERROR_LOG_PACKET)
890: IoAllocateErrorLogEntry(
891: DeviceObject,
892: (UCHAR) (sizeof(IO_ERROR_LOG_PACKET)
893: + (dumpCount * sizeof(ULONG)))
894: );
895:
896: if (errorLogEntry != NULL) {
897:
898: errorLogEntry->ErrorCode = errorCode;
899: errorLogEntry->DumpDataSize = dumpCount * sizeof(ULONG);
900: errorLogEntry->SequenceNumber = 0;
901: errorLogEntry->MajorFunctionCode = 0;
902: errorLogEntry->IoControlCode = 0;
903: errorLogEntry->RetryCount = 0;
904: errorLogEntry->UniqueErrorValue = uniqueErrorValue;
905: errorLogEntry->FinalStatus = status;
906: for (i = 0; i < dumpCount; i++)
907: errorLogEntry->DumpData[i] = dumpData[i];
908:
909: IoWriteErrorLogEntry(errorLogEntry);
910: }
911: }
912: }
913:
914: //
915: // Initialize current mouse input packet state.
916: //
917:
918: deviceExtension->MouseExtension.PreviousSignAndOverflow = 0;
919: deviceExtension->MouseExtension.InputState = MouseExpectingACK;
920:
921: I8xPrint((2, "I8042PRT-I8xInitializeMouse: exit\n"));
922:
923: return(status);
924: }
925:
926: VOID
927: I8xMouseConfiguration(
928: IN PDEVICE_EXTENSION DeviceExtension,
929: IN PUNICODE_STRING RegistryPath,
930: IN PUNICODE_STRING KeyboardDeviceName,
931: IN PUNICODE_STRING PointerDeviceName
932: )
933:
934: /*++
935:
936: Routine Description:
937:
938: This routine retrieves the configuration information for the mouse.
939:
940: Arguments:
941:
942: DeviceExtension - Pointer to the device extension.
943:
944: RegistryPath - Pointer to the null-terminated Unicode name of the
945: registry path for this driver.
946:
947: KeyboardDeviceName - Pointer to the Unicode string that will receive
948: the keyboard port device name.
949:
950: PointerDeviceName - Pointer to the Unicode string that will receive
951: the pointer port device name.
952:
953:
954: Return Value:
955:
956: None. As a side-effect, may set DeviceExtension->HardwarePresent.
957:
958: --*/
959: {
960: NTSTATUS status = STATUS_SUCCESS;
961: INTERFACE_TYPE interfaceType;
962: CONFIGURATION_TYPE controllerType = PointerController;
963: CONFIGURATION_TYPE peripheralType = PointerPeripheral;
964: ULONG i;
965:
966: for (i = 0; i < MaximumInterfaceType; i++) {
967:
968: //
969: // Get the registry information for this device.
970: //
971:
972: interfaceType = i;
973: status = IoQueryDeviceDescription(&interfaceType,
974: NULL,
975: &controllerType,
976: NULL,
977: &peripheralType,
978: NULL,
979: I8xMousePeripheralCallout,
980: (PVOID) DeviceExtension);
981:
982: if (DeviceExtension->HardwarePresent & MOUSE_HARDWARE_PRESENT) {
983:
984: //
985: // If we didn't already get these when determining the keyboard
986: // configuration, get the service parameters now (e.g.,
987: // user-configurable number of resends, polling iterations, etc.).
988: //
989:
990: if (!(DeviceExtension->HardwarePresent & KEYBOARD_HARDWARE_PRESENT))
991: I8xServiceParameters(
992: DeviceExtension,
993: RegistryPath,
994: KeyboardDeviceName,
995: PointerDeviceName
996: );
997:
998: //
999: // Initialize mouse-specific configuration parameters.
1000: //
1001:
1002: DeviceExtension->Configuration.MouseAttributes.MouseIdentifier =
1003: MOUSE_I8042_HARDWARE;
1004:
1005: break;
1006:
1007: } else {
1008: I8xPrint((
1009: 1,
1010: "I8042PRT-I8xMouseConfiguration: IoQueryDeviceDescription for bus type %d failed\n",
1011: interfaceType
1012: ));
1013: }
1014: }
1015: }
1016:
1017: NTSTATUS
1018: I8xMouseEnableTransmission(
1019: IN PDEVICE_OBJECT DeviceObject
1020: )
1021:
1022: /*++
1023:
1024: Routine Description:
1025:
1026: This routine sends an Enable command to the mouse hardware, causing
1027: the mouse to begin transmissions. It is called at initialization
1028: time, but only after the interrupt has been connected. This is
1029: necessary so the driver can keep its notion of the mouse input data
1030: state in sync with the hardware (i.e., for this type of mouse there is no
1031: way to differentiate the first byte of a packet; if the user is randomly
1032: moving the mouse during boot/initialization, the first mouse interrupt we
1033: receive following IoConnectInterrupt could be for a byte that is not the
1034: start of a packet, and we have no way to know that).
1035:
1036: Arguments:
1037:
1038: DeviceObject - Pointer to the device object.
1039:
1040: Return Value:
1041:
1042: Returns status.
1043:
1044: --*/
1045:
1046: {
1047: NTSTATUS status;
1048: PDEVICE_EXTENSION deviceExtension;
1049: PIO_ERROR_LOG_PACKET errorLogEntry;
1050: ULONG uniqueErrorValue;
1051: NTSTATUS errorCode = STATUS_SUCCESS;
1052: ULONG i;
1053: ULONG dumpCount = 0;
1054:
1055: #define DUMP_COUNT 4
1056: ULONG dumpData[DUMP_COUNT];
1057:
1058: I8xPrint((2, "I8042PRT-I8xMouseEnableTransmission: enter\n"));
1059:
1060: for (i = 0; i < DUMP_COUNT; i++)
1061: dumpData[i] = 0;
1062:
1063: //
1064: // Get the device extension.
1065: //
1066:
1067: deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
1068:
1069: //
1070: // Re-enable the mouse at the mouse hardware, so that it can transmit
1071: // data packets in continuous mode. Note that this is not the same
1072: // as enabling the mouse device at the 8042 controller. The mouse
1073: // hardware is sent an Enable command here, because it was
1074: // Disabled as a result of the mouse reset command performed
1075: // in I8xInitializeMouse().
1076: //
1077: // Note that we don't wait for an ACKNOWLEDGE back. The
1078: // ACKNOWLEDGE back will actually cause a mouse interrupt, which
1079: // then gets handled in the mouse ISR.
1080: //
1081:
1082: status = I8xPutBytePolled(
1083: (CCHAR) DataPort,
1084: NO_WAIT_FOR_ACKNOWLEDGE,
1085: (CCHAR) MouseDeviceType,
1086: deviceExtension,
1087: (UCHAR) ENABLE_MOUSE_TRANSMISSION
1088: );
1089: if (!NT_SUCCESS(status)) {
1090: I8xPrint((
1091: 1,
1092: "I8042PRT-I8xMouseEnableTransmission: failed write enable transmission, status 0x%x\n",
1093: status
1094: ));
1095:
1096: //
1097: // Set up error log info.
1098: //
1099:
1100: errorCode = I8042_MOU_ENABLE_XMIT;
1101: uniqueErrorValue = I8042_ERROR_VALUE_BASE + 475;
1102: dumpData[0] = KBDMOU_COULD_NOT_SEND_PARAM;
1103: dumpData[1] = DataPort;
1104: dumpData[2] = I8042_WRITE_TO_AUXILIARY_DEVICE;
1105: dumpData[3] = ENABLE_MOUSE_TRANSMISSION;
1106: dumpCount = 4;
1107:
1108: }
1109:
1110: I8xPrint((2, "I8042PRT-I8xMouseEnableTransmission: exit\n"));
1111:
1112: return(status);
1113: }
1114:
1115: NTSTATUS
1116: I8xMousePeripheralCallout(
1117: IN PVOID Context,
1118: IN PUNICODE_STRING PathName,
1119: IN INTERFACE_TYPE BusType,
1120: IN ULONG BusNumber,
1121: IN PKEY_VALUE_FULL_INFORMATION *BusInformation,
1122: IN CONFIGURATION_TYPE ControllerType,
1123: IN ULONG ControllerNumber,
1124: IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation,
1125: IN CONFIGURATION_TYPE PeripheralType,
1126: IN ULONG PeripheralNumber,
1127: IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation
1128: )
1129:
1130: /*++
1131:
1132: Routine Description:
1133:
1134: This is the callout routine sent as a parameter to
1135: IoQueryDeviceDescription. It grabs the pointer controller and
1136: peripheral configuration information.
1137:
1138: Arguments:
1139:
1140: Context - Context parameter that was passed in by the routine
1141: that called IoQueryDeviceDescription.
1142:
1143: PathName - The full pathname for the registry key.
1144:
1145: BusType - Bus interface type (Isa, Eisa, Mca, etc.).
1146:
1147: BusNumber - The bus sub-key (0, 1, etc.).
1148:
1149: BusInformation - Pointer to the array of pointers to the full value
1150: information for the bus.
1151:
1152: ControllerType - The controller type (should be PointerController).
1153:
1154: ControllerNumber - The controller sub-key (0, 1, etc.).
1155:
1156: ControllerInformation - Pointer to the array of pointers to the full
1157: value information for the controller key.
1158:
1159: PeripheralType - The peripheral type (should be PointerPeripheral).
1160:
1161: PeripheralNumber - The peripheral sub-key.
1162:
1163: PeripheralInformation - Pointer to the array of pointers to the full
1164: value information for the peripheral key.
1165:
1166:
1167: Return Value:
1168:
1169: None. If successful, will have the following side-effects:
1170:
1171: - Sets DeviceObject->DeviceExtension->HardwarePresent.
1172: - Sets configuration fields in
1173: DeviceObject->DeviceExtension->Configuration.
1174:
1175: --*/
1176: {
1177: PDEVICE_EXTENSION deviceExtension;
1178: PI8042_CONFIGURATION_INFORMATION configuration;
1179: UNICODE_STRING unicodeIdentifier;
1180: ANSI_STRING ansiString;
1181: PUCHAR controllerData;
1182: NTSTATUS status = STATUS_SUCCESS;
1183: ULONG i;
1184: ULONG listCount;
1185: PCM_PARTIAL_RESOURCE_DESCRIPTOR resourceDescriptor;
1186: CM_PARTIAL_RESOURCE_DESCRIPTOR tmpResourceDescriptor;
1187: BOOLEAN portInfoNeeded;
1188: BOOLEAN defaultInterruptShare;
1189: KINTERRUPT_MODE defaultInterruptMode;
1190:
1191: I8xPrint((
1192: 1,
1193: "I8042PRT-I8xMousePeripheralCallout: Path @ 0x%x, Bus Type 0x%x, Bus Number 0x%x\n",
1194: PathName, BusType, BusNumber
1195: ));
1196: I8xPrint((
1197: 1,
1198: " Controller Type 0x%x, Controller Number 0x%x, Controller info @ 0x%x\n",
1199: ControllerType, ControllerNumber, ControllerInformation
1200: ));
1201: I8xPrint((
1202: 1,
1203: " Peripheral Type 0x%x, Peripheral Number 0x%x, Peripheral info @ 0x%x\n",
1204: PeripheralType, PeripheralNumber, PeripheralInformation
1205: ));
1206:
1207: //
1208: // Get the length of the peripheral identifier information.
1209: //
1210:
1211: unicodeIdentifier.Length =
1212: (*(PeripheralInformation + IoQueryDeviceIdentifier))->DataLength;
1213:
1214: //
1215: // If we already have the configuration information for the
1216: // pointer peripheral, or if the peripheral identifier is missing,
1217: // just return.
1218: //
1219:
1220: deviceExtension = (PDEVICE_EXTENSION) Context;
1221: if ((deviceExtension->HardwarePresent & MOUSE_HARDWARE_PRESENT)
1222: || (unicodeIdentifier.Length == 0)) {
1223: return (status);
1224: }
1225:
1226: configuration = &deviceExtension->Configuration;
1227:
1228: //
1229: // Get the identifier information for the peripheral.
1230: //
1231:
1232: unicodeIdentifier.MaximumLength = unicodeIdentifier.Length;
1233: unicodeIdentifier.Buffer = (PWSTR) (((PUCHAR)(*(PeripheralInformation +
1234: IoQueryDeviceIdentifier))) +
1235: (*(PeripheralInformation +
1236: IoQueryDeviceIdentifier))->DataOffset);
1237: I8xPrint((
1238: 1,
1239: "I8042PRT-I8xMousePeripheralCallout: Mouse type %ws\n",
1240: unicodeIdentifier.Buffer));
1241:
1242: //
1243: // Verify that this is an i8042 mouse.
1244: //
1245:
1246: status = RtlUnicodeStringToAnsiString(
1247: &ansiString,
1248: &unicodeIdentifier,
1249: TRUE
1250: );
1251:
1252: if (!NT_SUCCESS(status)) {
1253: I8xPrint((
1254: 1,
1255: "I8042PRT-I8xMousePeripheralCallout: Could not convert identifier to Ansi\n"
1256: ));
1257: return(status);
1258: }
1259:
1260: if (strstr(ansiString.Buffer, "PS2")) {
1261:
1262: //
1263: // There is a mouse on the i8042 controller.
1264: //
1265:
1266: deviceExtension->HardwarePresent |= MOUSE_HARDWARE_PRESENT;
1267: }
1268:
1269: RtlFreeAnsiString(&ansiString);
1270:
1271: if (!(deviceExtension->HardwarePresent & MOUSE_HARDWARE_PRESENT)) {
1272: return(status);
1273: }
1274:
1275: if (!(deviceExtension->HardwarePresent & KEYBOARD_HARDWARE_PRESENT)) {
1276:
1277: //
1278: // If we don't already have the bus information as the result
1279: // of the keyboard configuration, grab it now.
1280: //
1281:
1282: configuration->InterfaceType = BusType;
1283: configuration->BusNumber = BusNumber;
1284: configuration->FloatingSave = I8042_FLOATING_SAVE;
1285: }
1286:
1287: if (configuration->InterfaceType == MicroChannel) {
1288: defaultInterruptShare = TRUE;
1289: defaultInterruptMode = LevelSensitive;
1290: } else {
1291: defaultInterruptShare = I8042_INTERRUPT_SHARE;
1292: defaultInterruptMode = I8042_INTERRUPT_MODE;
1293: }
1294:
1295: //
1296: // Look through the controller's resource list for interrupt
1297: // and (possibly) port configuration information.
1298: //
1299:
1300: if ((*(ControllerInformation + IoQueryDeviceConfigurationData))->DataLength != 0){
1301: controllerData = ((PUCHAR) (*(ControllerInformation +
1302: IoQueryDeviceConfigurationData))) +
1303: (*(ControllerInformation +
1304: IoQueryDeviceConfigurationData))->DataOffset;
1305:
1306: controllerData += FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR,
1307: PartialResourceList);
1308:
1309: listCount = ((PCM_PARTIAL_RESOURCE_LIST) controllerData)->Count;
1310:
1311: resourceDescriptor =
1312: ((PCM_PARTIAL_RESOURCE_LIST) controllerData)->PartialDescriptors;
1313:
1314: portInfoNeeded = configuration->PortListCount? FALSE:TRUE;
1315:
1316: for (i = 0; i < listCount; i++, resourceDescriptor++) {
1317: switch(resourceDescriptor->Type) {
1318: case CmResourceTypePort:
1319:
1320: if (portInfoNeeded) {
1321:
1322: //
1323: // If we don't already have the port information as
1324: // a result of the keyboard configuration, copy it
1325: // to the port list.
1326: //
1327:
1328: configuration->PortList[configuration->PortListCount] =
1329: *resourceDescriptor;
1330: configuration->PortList[configuration->PortListCount].ShareDisposition =
1331: I8042_REGISTER_SHARE? CmResourceShareShared:
1332: CmResourceShareDriverExclusive;
1333: configuration->PortListCount += 1;
1334:
1335: }
1336:
1337: break;
1338:
1339: case CmResourceTypeInterrupt:
1340:
1341: //
1342: // Copy the interrupt information.
1343: //
1344:
1345: configuration->MouseInterrupt = *resourceDescriptor;
1346: configuration->MouseInterrupt.ShareDisposition =
1347: defaultInterruptShare? CmResourceShareShared :
1348: CmResourceShareDeviceExclusive;
1349:
1350: break;
1351:
1352: default:
1353: break;
1354: }
1355: }
1356: }
1357:
1358: //
1359: // If no interrupt configuration information was found, use the
1360: // mouse driver defaults.
1361: //
1362:
1363: if (!(configuration->MouseInterrupt.Type & CmResourceTypeInterrupt)) {
1364:
1365: I8xPrint((
1366: 1,
1367: "I8042PRT-I8xMousePeripheralCallout: Using default mouse interrupt config\n"
1368: ));
1369:
1370: configuration->MouseInterrupt.Type = CmResourceTypeInterrupt;
1371: configuration->MouseInterrupt.ShareDisposition =
1372: defaultInterruptShare? CmResourceShareShared :
1373: CmResourceShareDeviceExclusive;
1374: configuration->MouseInterrupt.Flags =
1375: (defaultInterruptMode == Latched)? CM_RESOURCE_INTERRUPT_LATCHED :
1376: CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE;
1377: configuration->MouseInterrupt.u.Interrupt.Level = MOUSE_IRQL;
1378: configuration->MouseInterrupt.u.Interrupt.Vector = MOUSE_VECTOR;
1379: }
1380:
1381: I8xPrint((
1382: 1,
1383: "I8042PRT-I8xMousePeripheralCallout: Mouse interrupt config --\n"
1384: ));
1385: I8xPrint((
1386: 1,
1387: "%s, %s, Irq = %d\n",
1388: configuration->MouseInterrupt.ShareDisposition == CmResourceShareShared?
1389: "Sharable" : "NonSharable",
1390: configuration->MouseInterrupt.Flags == CM_RESOURCE_INTERRUPT_LATCHED?
1391: "Latched" : "Level Sensitive",
1392: configuration->MouseInterrupt.u.Interrupt.Vector
1393: ));
1394:
1395: //
1396: // If no port configuration information was found, use the
1397: // mouse driver defaults.
1398: //
1399:
1400: if (configuration->PortListCount == 0) {
1401:
1402: //
1403: // No port configuration information was found, so use
1404: // the driver defaults.
1405: //
1406:
1407: I8xPrint((
1408: 1,
1409: "I8042PRT-I8xMousePeripheralCallout: Using default port config\n"
1410: ));
1411:
1412: configuration->PortList[DataPort].Type = CmResourceTypePort;
1413: configuration->PortList[DataPort].Flags = I8042_PORT_TYPE;
1414: configuration->PortList[DataPort].ShareDisposition =
1415: I8042_REGISTER_SHARE? CmResourceShareShared:
1416: CmResourceShareDriverExclusive;
1417: configuration->PortList[DataPort].u.Port.Start.LowPart =
1418: I8042_PHYSICAL_BASE + I8042_DATA_REGISTER_OFFSET;
1419: configuration->PortList[DataPort].u.Port.Start.HighPart = 0;
1420: configuration->PortList[DataPort].u.Port.Length = I8042_REGISTER_LENGTH;
1421:
1422: configuration->PortList[CommandPort].Type = CmResourceTypePort;
1423: configuration->PortList[CommandPort].Flags = I8042_PORT_TYPE;
1424: configuration->PortList[CommandPort].ShareDisposition =
1425: I8042_REGISTER_SHARE? CmResourceShareShared:
1426: CmResourceShareDriverExclusive;
1427: configuration->PortList[CommandPort].u.Port.Start.LowPart =
1428: I8042_PHYSICAL_BASE + I8042_COMMAND_REGISTER_OFFSET;
1429: configuration->PortList[CommandPort].u.Port.Start.HighPart = 0;
1430: configuration->PortList[CommandPort].u.Port.Length = I8042_REGISTER_LENGTH;
1431:
1432: configuration->PortListCount = 2;
1433: } else if (configuration->PortListCount == 1) {
1434:
1435: //
1436: // Kludge for Jazz machines. Their ARC firmware neglects to
1437: // separate out the port addresses, so fix that up here.
1438: //
1439:
1440: configuration->PortList[CommandPort] = configuration->PortList[DataPort];
1441: configuration->PortList[CommandPort].u.Port.Start.LowPart +=
1442: I8042_COMMAND_REGISTER_OFFSET;
1443: configuration->PortListCount += 1;
1444: } else {
1445:
1446: //
1447: // Put the lowest port address range in the DataPort element of
1448: // the port list.
1449: //
1450:
1451: if (configuration->PortList[CommandPort].u.Port.Start.LowPart
1452: < configuration->PortList[DataPort].u.Port.Start.LowPart) {
1453: tmpResourceDescriptor = configuration->PortList[DataPort];
1454: configuration->PortList[DataPort] =
1455: configuration->PortList[CommandPort];
1456: configuration->PortList[CommandPort] = tmpResourceDescriptor;
1457: }
1458: }
1459:
1460: for (i = 0; i < configuration->PortListCount; i++) {
1461:
1462: I8xPrint((
1463: 1,
1464: " %s, Ports 0x%x - 0x%x\n",
1465: configuration->PortList[i].ShareDisposition
1466: == CmResourceShareShared? "Sharable" : "NonSharable",
1467: configuration->PortList[i].u.Port.Start.LowPart,
1468: configuration->PortList[i].u.Port.Start.LowPart +
1469: configuration->PortList[i].u.Port.Length - 1
1470: ));
1471: }
1472:
1473: return(status);
1474: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.