dcf1f34030ba298c0200d9eecc5cf89865cda37f
[reactos.git] / subsystems / ntvdm / hardware / timer.c
1 /*
2 * COPYRIGHT: GPL - See COPYING in the top level directory
3 * PROJECT: ReactOS Virtual DOS Machine
4 * FILE: timer.c
5 * PURPOSE: Programmable Interval Timer emulation -
6 * i82C54/8254 compatible
7 * PROGRAMMERS: Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
8 * Hermes Belusca-Maito (hermes.belusca@sfr.fr)
9 */
10
11 /* INCLUDES *******************************************************************/
12
13 #define NDEBUG
14
15 #include "emulator.h"
16 #include "io.h"
17 #include "timer.h"
18 #include "pic.h"
19
20 /* PRIVATE VARIABLES **********************************************************/
21
22 static PIT_CHANNEL PitChannels[PIT_CHANNELS];
23 PPIT_CHANNEL PitChannel2 = &PitChannels[2];
24
25 /* PRIVATE FUNCTIONS **********************************************************/
26
27 static VOID PitLatchChannelStatus(BYTE Channel)
28 {
29 if (Channel >= PIT_CHANNELS) return;
30
31 /*
32 * A given counter can be latched only one time until it gets unlatched.
33 * If the counter is latched and then is latched again later before the
34 * value is read, then this last latch command is ignored and the value
35 * will be the value at the time the first command was issued.
36 */
37 if (PitChannels[Channel].LatchStatusSet == FALSE)
38 {
39 BYTE StatusLatch = 0;
40 /** HACK!! **/BYTE NullCount = 0;/** HACK!! **/
41
42 StatusLatch = PitChannels[Channel].Out << 7 | NullCount << 6;
43 StatusLatch |= (PitChannels[Channel].ReadWriteMode & 0x03) << 4;
44 StatusLatch |= (PitChannels[Channel].Mode & 0x07) << 1;
45 StatusLatch |= (PitChannels[Channel].Bcd & 0x01);
46
47 /* Latch the counter's status */
48 PitChannels[Channel].LatchStatusSet = TRUE;
49 PitChannels[Channel].StatusLatch = StatusLatch;
50 }
51 }
52
53 static VOID PitLatchChannelCount(BYTE Channel)
54 {
55 if (Channel >= PIT_CHANNELS) return;
56
57 /*
58 * A given counter can be latched only one time until it gets unlatched.
59 * If the counter is latched and then is latched again later before the
60 * value is read, then this last latch command is ignored and the value
61 * will be the value at the time the first command was issued.
62 */
63 if (PitChannels[Channel].ReadStatus == 0x00)
64 {
65 /* Latch the counter's value */
66 PitChannels[Channel].ReadStatus = PitChannels[Channel].ReadWriteMode;
67
68 /* Convert the current value to BCD if needed */
69 PitChannels[Channel].OutputLatch =
70 READ_PIT_VALUE(PitChannels[Channel], PitChannels[Channel].CurrentValue);
71 }
72 }
73
74 static VOID PitSetOut(PPIT_CHANNEL Channel, BOOLEAN State)
75 {
76 /** HACK!! **\ if (State == Channel->Out) return; \** HACK!! **/
77
78 /* Set the new state of the OUT pin */
79 Channel->Out = State;
80
81 /* Call the callback */
82 if (!Channel->Gate) return; // HACK: This is a HACK until gates are properly used (needed for the speaker to work properly).
83 if (Channel->OutFunction) Channel->OutFunction(Channel->OutParam, State);
84 }
85
86 static VOID PitInitCounter(PPIT_CHANNEL Channel)
87 {
88 switch (Channel->Mode)
89 {
90 case PIT_MODE_INT_ON_TERMINAL_COUNT:
91 PitSetOut(Channel, FALSE);
92 break;
93
94 case PIT_MODE_HARDWARE_ONE_SHOT:
95 case PIT_MODE_RATE_GENERATOR:
96 case PIT_MODE_SQUARE_WAVE:
97 case PIT_MODE_SOFTWARE_STROBE:
98 case PIT_MODE_HARDWARE_STROBE:
99 PitSetOut(Channel, TRUE);
100 break;
101 }
102 }
103
104 static VOID PitWriteCommand(BYTE Value)
105 {
106 BYTE Channel = (Value >> 6) & 0x03;
107 BYTE ReadWriteMode = (Value >> 4) & 0x03;
108 BYTE Mode = (Value >> 1) & 0x07;
109 BOOLEAN IsBcd = Value & 0x01;
110
111 /*
112 * Check for valid PIT channel - Possible values: 0, 1, 2.
113 * A value of 3 is for Read-Back Command.
114 */
115 if (Channel > PIT_CHANNELS) return;
116
117 /* Read-Back Command */
118 if (Channel == PIT_CHANNELS)
119 {
120 if ((Value & 0x20) == 0) // Bit 5 (Count) == 0: We latch multiple counters' counts
121 {
122 if (Value & 0x02) PitLatchChannelCount(0);
123 if (Value & 0x04) PitLatchChannelCount(1);
124 if (Value & 0x08) PitLatchChannelCount(2);
125 }
126 if ((Value & 0x10) == 0) // Bit 4 (Status) == 0: We latch multiple counters' statuses
127 {
128 if (Value & 0x02) PitLatchChannelStatus(0);
129 if (Value & 0x04) PitLatchChannelStatus(1);
130 if (Value & 0x08) PitLatchChannelStatus(2);
131 }
132 return;
133 }
134
135 /* Check if this is a counter latch command... */
136 if (ReadWriteMode == 0)
137 {
138 PitLatchChannelCount(Channel);
139 return;
140 }
141
142 /* ... otherwise, set the modes and reset flip-flops */
143 PitChannels[Channel].ReadWriteMode = ReadWriteMode;
144 PitChannels[Channel].ReadStatus = 0x00;
145 PitChannels[Channel].WriteStatus = 0x00;
146
147 PitChannels[Channel].LatchStatusSet = FALSE;
148 PitChannels[Channel].StatusLatch = 0x00;
149
150 PitChannels[Channel].CountRegister = 0x00;
151 PitChannels[Channel].OutputLatch = 0x00;
152
153 /** HACK!! **/PitChannels[Channel].FlipFlop = FALSE;/** HACK!! **/
154
155 /* Fix the current value if we switch to BCD counting */
156 PitChannels[Channel].Bcd = IsBcd;
157 if (IsBcd && PitChannels[Channel].CurrentValue > 9999)
158 PitChannels[Channel].CurrentValue = 9999;
159
160 switch (Mode)
161 {
162 case 0:
163 case 1:
164 case 2:
165 case 3:
166 case 4:
167 case 5:
168 {
169 PitChannels[Channel].Mode = Mode;
170 break;
171 }
172
173 case 6:
174 case 7:
175 {
176 /*
177 * Modes 6 and 7 become PIT_MODE_RATE_GENERATOR
178 * and PIT_MODE_SQUARE_WAVE respectively.
179 */
180 PitChannels[Channel].Mode = Mode - 4;
181 break;
182 }
183 }
184
185 PitInitCounter(&PitChannels[Channel]);
186 }
187
188 static BYTE PitReadData(BYTE Channel)
189 {
190 LPBYTE ReadWriteMode = NULL;
191 LPWORD CurrentValue = NULL;
192
193 /*
194 * If the status was latched, the first read operation will return the
195 * latched status, whichever value (count or status) was latched first.
196 */
197 if (PitChannels[Channel].LatchStatusSet)
198 {
199 PitChannels[Channel].LatchStatusSet = FALSE;
200 return PitChannels[Channel].StatusLatch;
201 }
202
203 /* To be able to read the count asynchronously, latch it first if needed */
204 if (PitChannels[Channel].ReadStatus == 0) PitLatchChannelCount(Channel);
205
206 /* The count is now latched */
207 ASSERT(PitChannels[Channel].ReadStatus != 0);
208
209 ReadWriteMode = &PitChannels[Channel].ReadStatus ;
210 CurrentValue = &PitChannels[Channel].OutputLatch;
211
212 if (*ReadWriteMode & 1)
213 {
214 /* Read LSB */
215 *ReadWriteMode &= ~1;
216 return LOBYTE(*CurrentValue);
217 }
218
219 if (*ReadWriteMode & 2)
220 {
221 /* Read MSB */
222 *ReadWriteMode &= ~2;
223 return HIBYTE(*CurrentValue);
224 }
225
226 /* Shouldn't get here */
227 ASSERT(FALSE);
228 return 0;
229 }
230
231 static VOID PitWriteData(BYTE Channel, BYTE Value)
232 {
233 LPBYTE ReadWriteMode = NULL;
234
235 if (PitChannels[Channel].WriteStatus == 0x00)
236 {
237 PitChannels[Channel].WriteStatus = PitChannels[Channel].ReadWriteMode;
238 }
239
240 ASSERT(PitChannels[Channel].WriteStatus != 0);
241
242 ReadWriteMode = &PitChannels[Channel].WriteStatus;
243
244 if (*ReadWriteMode & 1)
245 {
246 /* Write LSB */
247 *ReadWriteMode &= ~1;
248 PitChannels[Channel].CountRegister &= 0xFF00;
249 PitChannels[Channel].CountRegister |= Value;
250 }
251 else if (*ReadWriteMode & 2)
252 {
253 /* Write MSB */
254 *ReadWriteMode &= ~2;
255 PitChannels[Channel].CountRegister &= 0x00FF;
256 PitChannels[Channel].CountRegister |= Value << 8;
257 }
258
259 /* ReadWriteMode went to zero: we are going to load the new count */
260 if (*ReadWriteMode == 0x00)
261 {
262 if (PitChannels[Channel].CountRegister == 0x0000)
263 {
264 /* Wrap around to the highest count */
265 if (PitChannels[Channel].Bcd)
266 PitChannels[Channel].CountRegister = 9999;
267 else
268 PitChannels[Channel].CountRegister = 0xFFFF; // 0x10000; // 65536
269 }
270
271 /* Convert the current value from BCD if needed */
272 PitChannels[Channel].CountRegister =
273 WRITE_PIT_VALUE(PitChannels[Channel], PitChannels[Channel].CountRegister);
274 PitChannels[Channel].ReloadValue = PitChannels[Channel].CountRegister;
275 }
276 }
277
278 static BYTE WINAPI PitReadPort(ULONG Port)
279 {
280 switch (Port)
281 {
282 case PIT_DATA_PORT(0):
283 case PIT_DATA_PORT(1):
284 case PIT_DATA_PORT(2):
285 {
286 return PitReadData(Port - PIT_DATA_PORT(0));
287 }
288 }
289
290 return 0;
291 }
292
293 static VOID WINAPI PitWritePort(ULONG Port, BYTE Data)
294 {
295 switch (Port)
296 {
297 case PIT_COMMAND_PORT:
298 {
299 PitWriteCommand(Data);
300 break;
301 }
302
303 case PIT_DATA_PORT(0):
304 case PIT_DATA_PORT(1):
305 case PIT_DATA_PORT(2):
306 {
307 PitWriteData(Port - PIT_DATA_PORT(0), Data);
308 break;
309 }
310 }
311 }
312
313 static VOID PitDecrementCount(PPIT_CHANNEL Channel, DWORD Count)
314 {
315 if (Count == 0) return;
316
317 switch (Channel->Mode)
318 {
319 case PIT_MODE_INT_ON_TERMINAL_COUNT:
320 {
321 /* Decrement the value */
322 if (Count > Channel->CurrentValue)
323 {
324 /* The value does not reload in this case */
325 Channel->CurrentValue = 0;
326 }
327 else Channel->CurrentValue -= Count;
328
329 /* Did it fall to the terminal count? */
330 if (Channel->CurrentValue == 0 && !Channel->Out)
331 {
332 /* Yes, raise the output line */
333 PitSetOut(Channel, TRUE);
334 }
335 break;
336 }
337
338 case PIT_MODE_RATE_GENERATOR:
339 {
340 BOOLEAN Reloaded = FALSE;
341
342 while (Count)
343 {
344 if ((Count > Channel->CurrentValue)
345 && (Channel->CurrentValue != 0))
346 {
347 /* Decrement the count */
348 Count -= Channel->CurrentValue;
349
350 /* Reload the value */
351 Channel->CurrentValue = Channel->ReloadValue;
352
353 /* Set the flag */
354 Reloaded = TRUE;
355 }
356 else
357 {
358 /* Decrement the value */
359 Channel->CurrentValue -= Count;
360
361 /* Clear the count */
362 Count = 0;
363
364 /* Did it fall to zero? */
365 if (Channel->CurrentValue == 0)
366 {
367 Channel->CurrentValue = Channel->ReloadValue;
368 Reloaded = TRUE;
369 }
370 }
371 }
372
373 /* If there was a reload, raise the output line */
374 if (Reloaded) PitSetOut(Channel, TRUE);
375
376 break;
377 }
378
379 case PIT_MODE_SQUARE_WAVE:
380 {
381 INT ReloadCount = 0;
382 WORD ReloadValue = Channel->ReloadValue;
383
384 /* The reload value must be even */
385 ReloadValue &= ~1;
386
387 while (Count)
388 {
389 if (((Count * 2) > Channel->CurrentValue)
390 && (Channel->CurrentValue != 0))
391 {
392 /* Decrement the count */
393 Count -= Channel->CurrentValue / 2;
394
395 /* Reload the value */
396 Channel->CurrentValue = ReloadValue;
397
398 /* Increment the reload count */
399 ReloadCount++;
400 }
401 else
402 {
403 /* Decrement the value */
404 Channel->CurrentValue -= Count * 2;
405
406 /* Clear the count */
407 Count = 0;
408
409 /* Did it fall to zero? */
410 if (Channel->CurrentValue == 0)
411 {
412 /* Reload the value */
413 Channel->CurrentValue = ReloadValue;
414
415 /* Increment the reload count */
416 ReloadCount++;
417 }
418 }
419 }
420
421 if (ReloadCount == 0) break;
422
423 /* Toggle the flip-flop if the number of reloads was odd */
424 if (ReloadCount & 1)
425 {
426 Channel->FlipFlop = !Channel->FlipFlop;
427 PitSetOut(Channel, !Channel->Out);
428 }
429
430 /* Was there any rising edge? */
431 if ((Channel->FlipFlop && (ReloadCount == 1)) || (ReloadCount > 1))
432 {
433 /* Yes, raise the output line */
434 PitSetOut(Channel, TRUE);
435 }
436
437 break;
438 }
439
440 case PIT_MODE_SOFTWARE_STROBE:
441 {
442 // TODO: NOT IMPLEMENTED
443 break;
444 }
445
446 case PIT_MODE_HARDWARE_ONE_SHOT:
447 case PIT_MODE_HARDWARE_STROBE:
448 {
449 /* These modes do not work on x86 PCs */
450 break;
451 }
452 }
453 }
454
455 /* PUBLIC FUNCTIONS ***********************************************************/
456
457 VOID PitSetOutFunction(BYTE Channel, LPVOID Param, PIT_OUT_FUNCTION OutFunction)
458 {
459 if (Channel >= PIT_CHANNELS) return;
460
461 PitChannels[Channel].OutParam = Param;
462 PitChannels[Channel].OutFunction = OutFunction;
463 }
464
465 VOID PitSetGate(BYTE Channel, BOOLEAN State)
466 {
467 if (Channel >= PIT_CHANNELS) return;
468 if (State == PitChannels[Channel].Gate) return;
469
470 /* UNIMPLEMENTED */
471 PitChannels[Channel].Gate = State;
472 }
473
474 VOID PitClock(DWORD Count)
475 {
476 UINT i;
477
478 if (Count == 0) return;
479
480 for (i = 0; i < PIT_CHANNELS; i++)
481 {
482 // if (!PitChannels[i].Counting) continue;
483 PitDecrementCount(&PitChannels[i], Count);
484 }
485 }
486
487 DWORD PitGetResolution(VOID)
488 {
489 INT i;
490 DWORD MinReloadValue = 65536;
491
492 for (i = 0; i < PIT_CHANNELS; i++)
493 {
494 DWORD ReloadValue = PitChannels[i].ReloadValue;
495
496 /* 0 means 65536 */
497 if (ReloadValue == 0) ReloadValue = 65536;
498
499 if (ReloadValue < MinReloadValue) MinReloadValue = ReloadValue;
500 }
501
502 /* Return the frequency resolution */
503 return PIT_BASE_FREQUENCY / MinReloadValue;
504 }
505
506 VOID PitInitialize(VOID)
507 {
508 /* Set up the timers to their default value */
509 PitSetOutFunction(0, NULL, NULL);
510 PitSetGate(0, TRUE);
511 PitSetOutFunction(1, NULL, NULL);
512 PitSetGate(1, TRUE);
513 PitSetOutFunction(2, NULL, NULL);
514 PitSetGate(2, FALSE);
515
516 /* Register the I/O Ports */
517 RegisterIoPort(PIT_COMMAND_PORT, NULL , PitWritePort);
518 RegisterIoPort(PIT_DATA_PORT(0), PitReadPort, PitWritePort);
519 RegisterIoPort(PIT_DATA_PORT(1), PitReadPort, PitWritePort);
520 RegisterIoPort(PIT_DATA_PORT(2), PitReadPort, PitWritePort);
521 }
522
523 /* EOF */