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