cdaacd263e3bacc138184f597a003166b7cf86db
[reactos.git] / subsystems / ntvdm / 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
18 /* PRIVATE VARIABLES **********************************************************/
19
20 static BYTE KeyboardQueue[KEYBOARD_BUFFER_SIZE];
21 static BOOLEAN KeyboardQueueEmpty = TRUE;
22 static UINT KeyboardQueueStart = 0;
23 static UINT KeyboardQueueEnd = 0;
24 static BYTE KeyboardData = 0, KeyboardResponse = 0;
25 static BOOLEAN KeyboardReadResponse = FALSE, KeyboardWriteResponse = FALSE;
26 static BYTE KeyboardConfig = PS2_DEFAULT_CONFIG;
27 static HANDLE QueueMutex = NULL;
28
29 static HANDLE InputThread = NULL;
30
31 /* PRIVATE FUNCTIONS **********************************************************/
32
33 static BOOLEAN KeyboardQueuePush(BYTE ScanCode)
34 {
35 BOOLEAN Result = TRUE;
36
37 WaitForSingleObject(QueueMutex, INFINITE);
38
39 /* Check if the keyboard queue is full */
40 if (!KeyboardQueueEmpty && (KeyboardQueueStart == KeyboardQueueEnd))
41 {
42 Result = FALSE;
43 goto Done;
44 }
45
46 /* Insert the value in the queue */
47 KeyboardQueue[KeyboardQueueEnd] = ScanCode;
48 KeyboardQueueEnd++;
49 KeyboardQueueEnd %= KEYBOARD_BUFFER_SIZE;
50
51 /* Since we inserted a value, it's not empty anymore */
52 KeyboardQueueEmpty = FALSE;
53
54 Done:
55 ReleaseMutex(QueueMutex);
56 return Result;
57 }
58
59 static BOOLEAN KeyboardQueuePop(BYTE *ScanCode)
60 {
61 BOOLEAN Result = TRUE;
62
63 WaitForSingleObject(QueueMutex, INFINITE);
64
65 /* Make sure the keyboard queue is not empty */
66 if (KeyboardQueueEmpty)
67 {
68 Result = FALSE;
69 goto Done;
70 }
71
72 /* Get the scan code */
73 *ScanCode = KeyboardQueue[KeyboardQueueStart];
74
75 /* Remove the value from the queue */
76 KeyboardQueueStart++;
77 KeyboardQueueStart %= KEYBOARD_BUFFER_SIZE;
78
79 /* Check if the queue is now empty */
80 if (KeyboardQueueStart == KeyboardQueueEnd)
81 {
82 KeyboardQueueEmpty = TRUE;
83 }
84
85 Done:
86 ReleaseMutex(QueueMutex);
87 return Result;
88 }
89
90 /* PUBLIC FUNCTIONS ***********************************************************/
91
92 BYTE KeyboardReadStatus()
93 {
94 BYTE Status = 0;
95
96 /* Set the first bit if the data can be read */
97 if (KeyboardReadResponse || !KeyboardQueueEmpty) Status |= 1 << 0;
98
99 /* Always set bit 2 */
100 Status |= 1 << 2;
101
102 /* Set bit 3 if the next byte goes to the controller */
103 if (KeyboardWriteResponse) Status |= 1 << 3;
104
105 return Status;
106 }
107
108 VOID KeyboardWriteCommand(BYTE Command)
109 {
110 switch (Command)
111 {
112 /* Read configuration byte */
113 case 0x20:
114 {
115 KeyboardResponse = KeyboardConfig;
116 KeyboardReadResponse = TRUE;
117 break;
118 }
119
120 /* Write configuration byte */
121 case 0x60:
122 /* Write controller output port */
123 case 0xD1:
124 /* Write keyboard output buffer */
125 case 0xD2:
126 /* Write mouse output buffer */
127 case 0xD3:
128 /* Write mouse input buffer */
129 case 0xD4:
130 {
131 /* These commands require a response */
132 KeyboardResponse = Command;
133 KeyboardWriteResponse = TRUE;
134 break;
135 }
136
137 /* Disable mouse */
138 case 0xA7:
139 {
140 // TODO: Mouse support
141 break;
142 }
143
144 /* Enable mouse */
145 case 0xA8:
146 {
147 // TODO: Mouse support
148 break;
149 }
150
151 /* Test mouse port */
152 case 0xA9:
153 {
154 KeyboardResponse = 0;
155 KeyboardReadResponse = TRUE;
156 break;
157 }
158
159 /* Test PS/2 controller */
160 case 0xAA:
161 {
162 KeyboardResponse = 0x55;
163 KeyboardReadResponse = TRUE;
164 break;
165 }
166
167 /* Disable keyboard */
168 case 0xAD:
169 {
170 // TODO: Not implemented
171 break;
172 }
173
174 /* Enable keyboard */
175 case 0xAE:
176 {
177 // TODO: Not implemented
178 break;
179 }
180
181 /* Read controller output port */
182 case 0xD0:
183 {
184 // TODO: Not implemented
185 break;
186 }
187
188 /* CPU Reset */
189 case 0xF0:
190 case 0xF2:
191 case 0xF4:
192 case 0xF6:
193 case 0xF8:
194 case 0xFA:
195 case 0xFC:
196 case 0xFE:
197 {
198 /* Stop the simulation */
199 VdmRunning = FALSE;
200 break;
201 }
202 }
203 }
204
205 BYTE KeyboardReadData()
206 {
207 /* If there was a response byte from the controller, return it */
208 if (KeyboardReadResponse)
209 {
210 KeyboardReadResponse = FALSE;
211 KeyboardData = KeyboardResponse;
212 }
213 else
214 {
215 /* Otherwise, read the data from the queue */
216 KeyboardQueuePop(&KeyboardData);
217 }
218
219 return KeyboardData;
220 }
221
222 VOID KeyboardWriteData(BYTE Data)
223 {
224 /* Check if the controller is waiting for a response */
225 if (KeyboardWriteResponse)
226 {
227 KeyboardWriteResponse = FALSE;
228
229 /* Check which command it was */
230 switch (KeyboardResponse)
231 {
232 /* Write configuration byte */
233 case 0x60:
234 {
235 KeyboardConfig = Data;
236 break;
237 }
238
239 /* Write controller output */
240 case 0xD1:
241 {
242 /* Check if bit 0 is unset */
243 if (!(Data & (1 << 0)))
244 {
245 /* CPU disabled - end simulation */
246 VdmRunning = FALSE;
247 }
248
249 /* Update the A20 line setting */
250 EmulatorSetA20(Data & (1 << 1));
251
252 break;
253 }
254
255 case 0xD2:
256 {
257 /* Push the data byte to the keyboard queue */
258 KeyboardQueuePush(Data);
259 break;
260 }
261
262 case 0xD3:
263 {
264 // TODO: Mouse support
265 break;
266 }
267
268 case 0xD4:
269 {
270 // TODO: Mouse support
271 break;
272 }
273 }
274
275 return;
276 }
277
278 // TODO: Implement PS/2 device commands
279 }
280
281 BYTE WINAPI PS2ReadPort(ULONG Port)
282 {
283 if (Port == PS2_CONTROL_PORT)
284 return KeyboardReadStatus();
285 else if (Port == PS2_DATA_PORT)
286 return KeyboardReadData();
287 else
288 return 0;
289 }
290
291 VOID WINAPI PS2WritePort(ULONG Port, BYTE Data)
292 {
293 if (Port == PS2_CONTROL_PORT)
294 KeyboardWriteCommand(Data);
295 else if (Port == PS2_DATA_PORT)
296 KeyboardWriteData(Data);
297 }
298
299 DWORD WINAPI InputThreadProc(LPVOID Parameter)
300 {
301 INT i;
302 HANDLE ConsoleInput = (HANDLE)Parameter;
303 INPUT_RECORD InputRecord;
304 DWORD Count;
305
306 while (VdmRunning)
307 {
308 /* Wait for an input record */
309 if (!ReadConsoleInput(ConsoleInput, &InputRecord, 1, &Count))
310 {
311 DWORD LastError = GetLastError();
312 DPRINT1("Error reading console input (0x%p, %lu) - Error %lu\n", ConsoleInput, Count, LastError);
313 return LastError;
314 }
315
316 ASSERT(Count != 0);
317
318 /* Check the event type */
319 switch (InputRecord.EventType)
320 {
321 case KEY_EVENT:
322 {
323 BYTE ScanCode = (BYTE)InputRecord.Event.KeyEvent.wVirtualScanCode;
324
325 /* If this is a key release, set the highest bit in the scan code */
326 if (!InputRecord.Event.KeyEvent.bKeyDown) ScanCode |= 0x80;
327
328 /* Push the scan code onto the keyboard queue */
329 for (i = 0; i < InputRecord.Event.KeyEvent.wRepeatCount; i++)
330 {
331 KeyboardQueuePush(ScanCode);
332 }
333
334 /* Keyboard IRQ */
335 PicInterruptRequest(1);
336 break;
337 }
338
339 case MOUSE_EVENT:
340 {
341 // TODO: NOT IMPLEMENTED
342 UNIMPLEMENTED;
343 break;
344 }
345
346 default:
347 {
348 /* Ignored */
349 break;
350 }
351 }
352 }
353
354 return 0;
355 }
356
357 BOOLEAN PS2Initialize(HANDLE ConsoleInput)
358 {
359 /* Create the mutex */
360 QueueMutex = CreateMutex(NULL, FALSE, NULL);
361
362 /* Start the input thread */
363 InputThread = CreateThread(NULL, 0, &InputThreadProc, ConsoleInput, 0, NULL);
364
365 // if (InputThread == NULL) return FALSE;
366
367 /* Register the I/O Ports */
368 RegisterIoPort(PS2_CONTROL_PORT, PS2ReadPort, PS2WritePort);
369 RegisterIoPort(PS2_DATA_PORT , PS2ReadPort, PS2WritePort);
370
371 return TRUE;
372 }
373
374 VOID PS2Cleanup(VOID)
375 {
376 /* Close the input thread handle */
377 if (InputThread != NULL) CloseHandle(InputThread);
378 InputThread = NULL;
379
380 CloseHandle(QueueMutex);
381 }
382
383 /* EOF */