7c1ed6d447213920027a30e19951d4f520053310
[reactos.git] / reactos / subsystems / ntvdm / hardware / ps2.c
1 /*
2 * COPYRIGHT: GPL - See COPYING in the top level directory
3 * PROJECT: ReactOS Virtual DOS Machine
4 * FILE: ps2.c
5 * PURPOSE: PS/2 controller emulation
6 * PROGRAMMERS: Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #define NDEBUG
12
13 #include "emulator.h"
14 #include "io.h"
15 #include "ps2.h"
16 #include "pic.h"
17 #include "mouse.h"
18 #include "../bios/bios32/moubios32.h"
19
20 /* PRIVATE VARIABLES **********************************************************/
21
22 static BYTE KeyboardQueue[KEYBOARD_BUFFER_SIZE];
23 static BOOLEAN KeyboardQueueEmpty = TRUE;
24 static UINT KeyboardQueueStart = 0;
25 static UINT KeyboardQueueEnd = 0;
26 static BYTE KeyboardData = 0, KeyboardResponse = 0;
27 static BOOLEAN KeyboardReadResponse = FALSE, KeyboardWriteResponse = FALSE;
28 static BYTE KeyboardConfig = PS2_DEFAULT_CONFIG;
29 static HANDLE QueueMutex = NULL;
30
31 /* PRIVATE FUNCTIONS **********************************************************/
32
33 static BYTE WINAPI PS2ReadPort(ULONG Port)
34 {
35 if (Port == PS2_CONTROL_PORT)
36 {
37 BYTE Status = 0;
38
39 /* Set the first bit if the data can be read */
40 if (KeyboardReadResponse || !KeyboardQueueEmpty) Status |= 1 << 0;
41
42 /* Always set bit 2 */
43 Status |= 1 << 2;
44
45 /* Set bit 3 if the next byte goes to the controller */
46 if (KeyboardWriteResponse) Status |= 1 << 3;
47
48 return Status;
49 }
50 else if (Port == PS2_DATA_PORT)
51 {
52 /* If there was a response byte from the controller, return it */
53 if (KeyboardReadResponse)
54 {
55 KeyboardReadResponse = FALSE;
56 KeyboardData = KeyboardResponse;
57 }
58
59 return KeyboardData;
60 }
61 else return 0;
62 }
63
64 static VOID WINAPI PS2WritePort(ULONG Port, BYTE Data)
65 {
66 if (Port == PS2_CONTROL_PORT)
67 {
68 switch (Data)
69 {
70 /* Read configuration byte */
71 case 0x20:
72 {
73 KeyboardResponse = KeyboardConfig;
74 KeyboardReadResponse = TRUE;
75 break;
76 }
77
78 /* Write configuration byte */
79 case 0x60:
80 /* Write controller output port */
81 case 0xD1:
82 /* Write keyboard output buffer */
83 case 0xD2:
84 /* Write mouse output buffer */
85 case 0xD3:
86 /* Write mouse input buffer */
87 case 0xD4:
88 {
89 /* These commands require a response */
90 KeyboardResponse = Data;
91 KeyboardWriteResponse = TRUE;
92 break;
93 }
94
95 /* Disable mouse */
96 case 0xA7:
97 {
98 // TODO: Not implemented
99 break;
100 }
101
102 /* Enable mouse */
103 case 0xA8:
104 {
105 // TODO: Not implemented
106 break;
107 }
108
109 /* Test mouse port */
110 case 0xA9:
111 {
112 KeyboardResponse = 0;
113 KeyboardReadResponse = TRUE;
114 break;
115 }
116
117 /* Test PS/2 controller */
118 case 0xAA:
119 {
120 KeyboardResponse = 0x55;
121 KeyboardReadResponse = TRUE;
122 break;
123 }
124
125 /* Disable keyboard */
126 case 0xAD:
127 {
128 // TODO: Not implemented
129 break;
130 }
131
132 /* Enable keyboard */
133 case 0xAE:
134 {
135 // TODO: Not implemented
136 break;
137 }
138
139 /* Read controller output port */
140 case 0xD0:
141 {
142 // TODO: Not implemented
143 break;
144 }
145
146 /* CPU Reset */
147 case 0xF0:
148 case 0xF2:
149 case 0xF4:
150 case 0xF6:
151 case 0xF8:
152 case 0xFA:
153 case 0xFC:
154 case 0xFE:
155 {
156 /* Stop the VDM */
157 EmulatorTerminate();
158 break;
159 }
160 }
161 }
162 else if (Port == PS2_DATA_PORT)
163 {
164 /* Check if the controller is waiting for a response */
165 if (KeyboardWriteResponse)
166 {
167 KeyboardWriteResponse = FALSE;
168
169 /* Check which command it was */
170 switch (KeyboardResponse)
171 {
172 /* Write configuration byte */
173 case 0x60:
174 {
175 KeyboardConfig = Data;
176 break;
177 }
178
179 /* Write controller output */
180 case 0xD1:
181 {
182 /* Check if bit 0 is unset */
183 if (!(Data & (1 << 0)))
184 {
185 /* CPU disabled - Stop the VDM */
186 EmulatorTerminate();
187 }
188
189 /* Update the A20 line setting */
190 EmulatorSetA20(Data & (1 << 1));
191
192 break;
193 }
194
195 case 0xD2:
196 {
197 /* Push the data byte to the keyboard queue */
198 KeyboardQueuePush(Data);
199 break;
200 }
201
202 case 0xD3:
203 {
204 // TODO: Mouse support
205 break;
206 }
207
208 case 0xD4:
209 {
210 MouseCommand(Data);
211 break;
212 }
213 }
214
215 return;
216 }
217
218 // TODO: Implement PS/2 device commands
219 }
220 }
221
222 /* PUBLIC FUNCTIONS ***********************************************************/
223
224 BOOLEAN KeyboardQueuePush(BYTE ScanCode)
225 {
226 BOOLEAN Result = TRUE;
227
228 WaitForSingleObject(QueueMutex, INFINITE);
229
230 /* Check if the keyboard queue is full */
231 if (!KeyboardQueueEmpty && (KeyboardQueueStart == KeyboardQueueEnd))
232 {
233 Result = FALSE;
234 goto Done;
235 }
236
237 /* Insert the value in the queue */
238 KeyboardQueue[KeyboardQueueEnd] = ScanCode;
239 KeyboardQueueEnd++;
240 KeyboardQueueEnd %= KEYBOARD_BUFFER_SIZE;
241
242 /* Since we inserted a value, it's not empty anymore */
243 KeyboardQueueEmpty = FALSE;
244
245 Done:
246 ReleaseMutex(QueueMutex);
247 return Result;
248 }
249
250 BOOLEAN KeyboardQueuePop(BYTE *ScanCode)
251 {
252 BOOLEAN Result = TRUE;
253
254 /* Make sure the keyboard queue is not empty (fast check) */
255 if (KeyboardQueueEmpty) return FALSE;
256
257 WaitForSingleObject(QueueMutex, INFINITE);
258
259 /*
260 * Recheck whether keyboard queue is not empty (it
261 * may have changed after having grabbed the mutex).
262 */
263 if (KeyboardQueueEmpty)
264 {
265 Result = FALSE;
266 goto Done;
267 }
268
269 /* Get the scan code */
270 *ScanCode = KeyboardQueue[KeyboardQueueStart];
271
272 /* Remove the value from the queue */
273 KeyboardQueueStart++;
274 KeyboardQueueStart %= KEYBOARD_BUFFER_SIZE;
275
276 /* Check if the queue is now empty */
277 if (KeyboardQueueStart == KeyboardQueueEnd)
278 {
279 KeyboardQueueEmpty = TRUE;
280 }
281
282 Done:
283 ReleaseMutex(QueueMutex);
284 return Result;
285 }
286
287 VOID PS2Dispatch(PINPUT_RECORD InputRecord)
288 {
289 /* Check the event type */
290 switch (InputRecord->EventType)
291 {
292 case KEY_EVENT:
293 {
294 WORD i;
295 BYTE ScanCode = (BYTE)InputRecord->Event.KeyEvent.wVirtualScanCode;
296
297 /* If this is a key release, set the highest bit in the scan code */
298 if (!InputRecord->Event.KeyEvent.bKeyDown) ScanCode |= 0x80;
299
300 /* Push the scan code onto the keyboard queue */
301 for (i = 0; i < InputRecord->Event.KeyEvent.wRepeatCount; i++)
302 {
303 KeyboardQueuePush(ScanCode);
304 }
305
306 break;
307 }
308
309 case MOUSE_EVENT:
310 {
311 /* Notify the BIOS driver */
312 MouseBiosUpdatePosition(&InputRecord->Event.MouseEvent.dwMousePosition);
313
314 // TODO: PS/2, other stuff
315
316 break;
317 }
318
319 /* We ignore all the rest */
320 default:
321 break;
322 }
323 }
324
325 VOID GenerateKeyboardInterrupts(VOID)
326 {
327 /* Generate an IRQ 1 if there is a key ready in the queue */
328 if (KeyboardQueuePop(&KeyboardData)) PicInterruptRequest(1);
329 }
330
331 BOOLEAN PS2Initialize(HANDLE ConsoleInput)
332 {
333 DWORD ConInMode;
334
335 /* Create the mutex */
336 QueueMutex = CreateMutex(NULL, FALSE, NULL);
337
338 /* Register the I/O Ports */
339 RegisterIoPort(PS2_CONTROL_PORT, PS2ReadPort, PS2WritePort);
340 RegisterIoPort(PS2_DATA_PORT , PS2ReadPort, PS2WritePort);
341
342 if (GetConsoleMode(ConsoleInput, &ConInMode))
343 {
344 #if 0
345 if (MousePresent)
346 {
347 #endif
348 /* Support mouse input events if there is a mouse on the system */
349 ConInMode |= ENABLE_MOUSE_INPUT;
350 #if 0
351 }
352 else
353 {
354 /* Do not support mouse input events if there is no mouse on the system */
355 ConInMode &= ~ENABLE_MOUSE_INPUT;
356 }
357 #endif
358
359 SetConsoleMode(ConsoleInput, ConInMode);
360 }
361
362 return TRUE;
363 }
364
365 VOID PS2Cleanup(VOID)
366 {
367 CloseHandle(QueueMutex);
368 }
369
370 /* EOF */