b7e6c13a9aff8f73c376e5f647b167365d7228e2
[reactos.git] / reactos / subsystems / mvdm / 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 * Hermes Belusca-Maito (hermes.belusca@sfr.fr)
8 */
9
10 /* INCLUDES *******************************************************************/
11
12 #define NDEBUG
13
14 #include "emulator.h"
15 #include "io.h"
16 #include "ps2.h"
17 #include "pic.h"
18
19 /* PRIVATE VARIABLES **********************************************************/
20
21 #define BUFFER_SIZE 32
22
23 typedef struct _PS2_PORT
24 {
25 BOOLEAN IsEnabled;
26
27 BOOLEAN QueueEmpty;
28 BYTE Queue[BUFFER_SIZE];
29 UINT QueueStart;
30 UINT QueueEnd;
31 HANDLE QueueMutex;
32
33 LPVOID Param;
34 PS2_DEVICE_CMDPROC DeviceCommand;
35 } PS2_PORT, *PPS2_PORT;
36
37 /*
38 * Port 1: Keyboard
39 * Port 2: Mouse
40 */
41 #define PS2_PORTS 2
42 static PS2_PORT Ports[PS2_PORTS];
43
44 #define PS2_DEFAULT_CONFIG 0x47
45 static BYTE ControllerConfig = PS2_DEFAULT_CONFIG;
46 static BYTE ControllerCommand = 0x00;
47
48 static BYTE StatusRegister = 0x00;
49 // static BYTE InputBuffer = 0x00; // PS/2 Input Buffer
50 static BYTE OutputBuffer = 0x00; // PS/2 Output Buffer
51
52 /* PRIVATE FUNCTIONS **********************************************************/
53
54 static VOID PS2SendCommand(PPS2_PORT Port, BYTE Command)
55 {
56 if (!Port->IsEnabled) return;
57
58 /* Call the device command */
59 if (Port->DeviceCommand) Port->DeviceCommand(Port->Param, Command);
60 }
61
62 static BYTE WINAPI PS2ReadPort(USHORT Port)
63 {
64 if (Port == PS2_CONTROL_PORT)
65 {
66 /* Be sure bit 2 is always set */
67 StatusRegister |= 1 << 2;
68
69 // FIXME: Should clear bits 6 and 7 because there are
70 // no timeouts and no parity errors.
71
72 return StatusRegister;
73 }
74 else if (Port == PS2_DATA_PORT)
75 {
76 /*
77 * If there is something to read (response byte from the
78 * controller or data from a PS/2 device), read it.
79 */
80 if (StatusRegister & (1 << 0)) // || StatusRegister & (1 << 5) for second PS/2 port
81 StatusRegister &= ~(1 << 0); // StatusRegister &= ~(1 << 5);
82
83 // FIXME: We may check there whether there is data latched in
84 // PS2 ports 1 or 2 (keyboard or mouse) and retrieve it there...
85
86 /* Always return the available byte stored in the output buffer */
87 return OutputBuffer;
88 }
89
90 return 0x00;
91 }
92
93 static VOID WINAPI PS2WritePort(USHORT Port, BYTE Data)
94 {
95 if (Port == PS2_CONTROL_PORT)
96 {
97 switch (Data)
98 {
99 /* Read configuration byte */
100 case 0x20:
101 {
102 OutputBuffer = ControllerConfig;
103 StatusRegister |= (1 << 0); // There is something to read
104 break;
105 }
106
107 /* Write configuration byte */
108 case 0x60:
109 /* Write controller output port */
110 case 0xD1:
111 /* Write to the first PS/2 port output buffer */
112 case 0xD2:
113 /* Write to the second PS/2 port output buffer */
114 case 0xD3:
115 /* Write to the second PS/2 port input buffer */
116 case 0xD4:
117 {
118 /* These commands require a response */
119 ControllerCommand = Data;
120 StatusRegister |= (1 << 3); // This is a controller command
121 break;
122 }
123
124 /* Disable second PS/2 port */
125 case 0xA7:
126 {
127 Ports[1].IsEnabled = FALSE;
128 break;
129 }
130
131 /* Enable second PS/2 port */
132 case 0xA8:
133 {
134 Ports[1].IsEnabled = TRUE;
135 break;
136 }
137
138 /* Test second PS/2 port */
139 case 0xA9:
140 {
141 OutputBuffer = 0x00; // Success code
142 StatusRegister |= (1 << 0); // There is something to read
143 break;
144 }
145
146 /* Test PS/2 controller */
147 case 0xAA:
148 {
149 OutputBuffer = 0x55; // Success code
150 StatusRegister |= (1 << 0); // There is something to read
151 break;
152 }
153
154 /* Test first PS/2 port */
155 case 0xAB:
156 {
157 OutputBuffer = 0x00; // Success code
158 StatusRegister |= (1 << 0); // There is something to read
159 break;
160 }
161
162 /* Disable first PS/2 port */
163 case 0xAD:
164 {
165 Ports[0].IsEnabled = FALSE;
166 break;
167 }
168
169 /* Enable first PS/2 port */
170 case 0xAE:
171 {
172 Ports[0].IsEnabled = TRUE;
173 break;
174 }
175
176 /* Read controller output port */
177 case 0xD0:
178 {
179 // TODO: Not implemented
180 break;
181 }
182
183 /* CPU Reset */
184 case 0xF0:
185 case 0xF2:
186 case 0xF4:
187 case 0xF6:
188 case 0xF8:
189 case 0xFA:
190 case 0xFC:
191 case 0xFE:
192 {
193 /* Stop the VDM */
194 EmulatorTerminate();
195 break;
196 }
197 }
198 }
199 else if (Port == PS2_DATA_PORT)
200 {
201 /* Check if the controller is waiting for a response */
202 if (StatusRegister & (1 << 3)) // If we have data for the controller
203 {
204 StatusRegister &= ~(1 << 3);
205
206 /* Check which command it was */
207 switch (ControllerCommand)
208 {
209 /* Write configuration byte */
210 case 0x60:
211 {
212 ControllerConfig = Data;
213 break;
214 }
215
216 /* Write controller output */
217 case 0xD1:
218 {
219 /* Check if bit 0 is unset */
220 if (!(Data & (1 << 0)))
221 {
222 /* CPU disabled - Stop the VDM */
223 EmulatorTerminate();
224 }
225
226 /* Update the A20 line setting */
227 EmulatorSetA20(Data & (1 << 1));
228
229 break;
230 }
231
232 /* Push the data byte into the first PS/2 port queue */
233 case 0xD2:
234 {
235 PS2QueuePush(0, Data);
236 break;
237 }
238
239 /* Push the data byte into the second PS/2 port queue */
240 case 0xD3:
241 {
242 PS2QueuePush(1, Data);
243 break;
244 }
245
246 /*
247 * Send a command to the second PS/2 port (by default
248 * it is a command for the first PS/2 port)
249 */
250 case 0xD4:
251 {
252 PS2SendCommand(&Ports[1], Data);
253 break;
254 }
255 }
256
257 return;
258 }
259
260 /* By default, send a command to the first PS/2 port */
261 PS2SendCommand(&Ports[0], Data);
262 }
263 }
264
265 static BOOLEAN PS2PortQueueRead(BYTE PS2Port)
266 {
267 BOOLEAN Result = TRUE;
268 PPS2_PORT Port;
269
270 if (PS2Port >= PS2_PORTS) return FALSE;
271 Port = &Ports[PS2Port];
272
273 if (!Port->IsEnabled) return FALSE;
274
275 /* Make sure the queue is not empty (fast check) */
276 if (Port->QueueEmpty)
277 {
278 /* Only the keyboard should have its last data latched */
279 // FIXME: Alternatively this can be done in PS2ReadPort when
280 // we read PS2_DATA_PORT. What is the best solution??
281 if (PS2Port == 0)
282 {
283 OutputBuffer = Port->Queue[(Port->QueueStart - 1) % BUFFER_SIZE];
284 }
285
286 return FALSE;
287 }
288
289 WaitForSingleObject(Port->QueueMutex, INFINITE);
290
291 /*
292 * Recheck whether the queue is not empty (it may
293 * have changed after having grabbed the mutex).
294 */
295 if (Port->QueueEmpty)
296 {
297 Result = FALSE;
298 goto Done;
299 }
300
301 /* Get the data */
302 OutputBuffer = Port->Queue[Port->QueueStart];
303 StatusRegister |= (1 << 0); // There is something to read
304 // Sometimes StatusRegister |= (1 << 5); for the second PS/2 port
305
306 /* Remove the value from the queue */
307 Port->QueueStart++;
308 Port->QueueStart %= BUFFER_SIZE;
309
310 /* Check if the queue is now empty */
311 if (Port->QueueStart == Port->QueueEnd)
312 Port->QueueEmpty = TRUE;
313
314 Done:
315 ReleaseMutex(Port->QueueMutex);
316 return Result;
317 }
318
319 /* PUBLIC FUNCTIONS ***********************************************************/
320
321 VOID PS2SetDeviceCmdProc(BYTE PS2Port, LPVOID Param, PS2_DEVICE_CMDPROC DeviceCommand)
322 {
323 if (PS2Port >= PS2_PORTS) return;
324
325 Ports[PS2Port].Param = Param;
326 Ports[PS2Port].DeviceCommand = DeviceCommand;
327 }
328
329 // PS2SendToPort
330 BOOLEAN PS2QueuePush(BYTE PS2Port, BYTE Data)
331 {
332 BOOLEAN Result = TRUE;
333 PPS2_PORT Port;
334
335 if (PS2Port >= PS2_PORTS) return FALSE;
336 Port = &Ports[PS2Port];
337
338 if (!Port->IsEnabled) return FALSE;
339
340 WaitForSingleObject(Port->QueueMutex, INFINITE);
341
342 /* Check if the queue is full */
343 if (!Port->QueueEmpty && (Port->QueueStart == Port->QueueEnd))
344 {
345 Result = FALSE;
346 goto Done;
347 }
348
349 /* Insert the value in the queue */
350 Port->Queue[Port->QueueEnd] = Data;
351 Port->QueueEnd++;
352 Port->QueueEnd %= BUFFER_SIZE;
353
354 /* The queue is not empty anymore */
355 Port->QueueEmpty = FALSE;
356
357 /*
358 // Get the data
359 OutputBuffer = Port->Queue[Port->QueueStart];
360 StatusRegister |= (1 << 0); // There is something to read
361 // FIXME: Sometimes StatusRegister |= (1 << 5); for the second PS/2 port
362
363 if (PS2Port == 0)
364 PicInterruptRequest(1);
365 else if (PS2Port == 1)
366 PicInterruptRequest(12);
367 */
368
369 Done:
370 ReleaseMutex(Port->QueueMutex);
371 return Result;
372 }
373
374 VOID GenerateIrq1(VOID)
375 {
376 /* Generate an interrupt if interrupts for the first PS/2 port are enabled */
377 if (ControllerConfig & 0x01)
378 {
379 /* Generate an IRQ 1 if there is data ready in the output queue */
380 if (PS2PortQueueRead(0)) PicInterruptRequest(1);
381 }
382 }
383
384 VOID GenerateIrq12(VOID)
385 {
386 /* Generate an interrupt if interrupts for the second PS/2 port are enabled */
387 if (ControllerConfig & 0x02)
388 {
389 /* Generate an IRQ 12 if there is data ready in the output queue */
390 if (PS2PortQueueRead(1)) PicInterruptRequest(12);
391 }
392 }
393
394 BOOLEAN PS2Initialize(VOID)
395 {
396 /* Initialize the PS/2 ports */
397 Ports[0].IsEnabled = TRUE;
398 Ports[0].QueueEmpty = TRUE;
399 Ports[0].QueueStart = 0;
400 Ports[0].QueueEnd = 0;
401 Ports[0].QueueMutex = CreateMutex(NULL, FALSE, NULL);
402
403 Ports[1].IsEnabled = TRUE;
404 Ports[1].QueueEmpty = TRUE;
405 Ports[1].QueueStart = 0;
406 Ports[1].QueueEnd = 0;
407 Ports[1].QueueMutex = CreateMutex(NULL, FALSE, NULL);
408
409 /* Register the I/O Ports */
410 RegisterIoPort(PS2_CONTROL_PORT, PS2ReadPort, PS2WritePort);
411 RegisterIoPort(PS2_DATA_PORT , PS2ReadPort, PS2WritePort);
412
413 return TRUE;
414 }
415
416 VOID PS2Cleanup(VOID)
417 {
418 CloseHandle(Ports[1].QueueMutex);
419 CloseHandle(Ports[0].QueueMutex);
420 }
421
422 /* EOF */