[CMAKE]
[reactos.git] / hal / halx86 / generic / timer.c
1 /*
2 * PROJECT: ReactOS HAL
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: hal/halx86/generic/timer.c
5 * PURPOSE: HAL Timer Routines
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include <hal.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 /* GLOBALS *******************************************************************/
16
17 ULONG HalpPerfCounterCutoff;
18 BOOLEAN HalpClockSetMSRate;
19 ULONG HalpCurrentTimeIncrement;
20 ULONG HalpCurrentRollOver;
21 ULONG HalpNextMSRate = 14;
22 ULONG HalpLargestClockMS = 15;
23
24 LARGE_INTEGER HalpRolloverTable[15] =
25 {
26 {{1197, 10032}},
27 {{2394, 20064}},
28 {{3591, 30096}},
29 {{4767, 39952}},
30 {{5964, 49984}},
31 {{7161, 60016}},
32 {{8358, 70048}},
33 {{9555, 80080}},
34 {{10731, 89936}},
35 {{11949, 100144}},
36 {{13125, 110000}},
37 {{14322, 120032}},
38 {{15519, 130064}},
39 {{16695, 139920}},
40 {{17892, 149952}}
41 };
42
43 /* PRIVATE FUNCTIONS *********************************************************/
44
45 VOID
46 NTAPI
47 INIT_FUNCTION
48 HalpInitializeClock(VOID)
49 {
50 PKPRCB Prcb = KeGetCurrentPrcb();
51 ULONG Increment;
52 USHORT RollOver;
53 ULONG_PTR Flags;
54 TIMER_CONTROL_PORT_REGISTER TimerControl;
55
56 /* Check the CPU Type */
57 if (Prcb->CpuType <= 4)
58 {
59 /* 486's or equal can't go higher then 10ms */
60 HalpLargestClockMS = 10;
61 HalpNextMSRate = 9;
62 }
63
64 /* Get increment and rollover for the largest time clock ms possible */
65 Increment = HalpRolloverTable[HalpLargestClockMS - 1].HighPart;
66 RollOver = (USHORT)HalpRolloverTable[HalpLargestClockMS - 1].LowPart;
67
68 /* Set the maximum and minimum increment with the kernel */
69 HalpCurrentTimeIncrement = Increment;
70 KeSetTimeIncrement(Increment, HalpRolloverTable[0].HighPart);
71
72 /* Disable interrupts */
73 Flags = __readeflags();
74 _disable();
75
76 /* Program the PIT for binary mode */
77 TimerControl.BcdMode = FALSE;
78
79 /*
80 * Program the PIT to generate a normal rate wave (Mode 3) on channel 0.
81 * Channel 0 is used for the IRQ0 clock interval timer, and channel
82 * 1 is used for DRAM refresh.
83 *
84 * Mode 2 gives much better accuracy than Mode 3.
85 */
86 TimerControl.OperatingMode = PitOperatingMode2;
87 TimerControl.Channel = PitChannel0;
88
89 /* Set the access mode that we'll use to program the reload value */
90 TimerControl.AccessMode = PitAccessModeLowHigh;
91
92 /* Now write the programming bits */
93 __outbyte(TIMER_CONTROL_PORT, TimerControl.Bits);
94
95 /* Next we write the reload value for channel 0 */
96 __outbyte(TIMER_CHANNEL0_DATA_PORT, RollOver & 0xFF);
97 __outbyte(TIMER_CHANNEL0_DATA_PORT, RollOver >> 8);
98
99 /* Restore interrupts if they were previously enabled */
100 __writeeflags(Flags);
101
102 /* Save rollover and return */
103 HalpCurrentRollOver = RollOver;
104 }
105
106 #ifdef _M_IX86
107 #ifndef _MINIHAL_
108 VOID
109 FASTCALL
110 HalpClockInterruptHandler(IN PKTRAP_FRAME TrapFrame)
111 {
112 KIRQL Irql;
113
114 /* Enter trap */
115 KiEnterInterruptTrap(TrapFrame);
116
117 /* Start the interrupt */
118 if (HalBeginSystemInterrupt(CLOCK2_LEVEL, PRIMARY_VECTOR_BASE, &Irql))
119 {
120 /* Update the performance counter */
121 HalpPerfCounter.QuadPart += HalpCurrentRollOver;
122 HalpPerfCounterCutoff = KiEnableTimerWatchdog;
123
124 /* Check if someone changed the time rate */
125 if (HalpClockSetMSRate)
126 {
127 /* Not yet supported */
128 UNIMPLEMENTED;
129 while (TRUE);
130 }
131
132 /* Update the system time -- the kernel will exit this trap */
133 KeUpdateSystemTime(TrapFrame, HalpCurrentTimeIncrement, Irql);
134 }
135
136 /* Spurious, just end the interrupt */
137 KiEoiHelper(TrapFrame);
138 }
139
140 VOID
141 FASTCALL
142 HalpProfileInterruptHandler(IN PKTRAP_FRAME TrapFrame)
143 {
144 KIRQL Irql;
145
146 /* Enter trap */
147 KiEnterInterruptTrap(TrapFrame);
148
149 /* Start the interrupt */
150 if (HalBeginSystemInterrupt(PROFILE_LEVEL, PRIMARY_VECTOR_BASE + 8, &Irql))
151 {
152 /* Profiling isn't yet enabled */
153 UNIMPLEMENTED;
154 while (TRUE);
155 }
156
157 /* Spurious, just end the interrupt */
158 KiEoiHelper(TrapFrame);
159 }
160 #endif
161
162 #endif
163
164 /* PUBLIC FUNCTIONS ***********************************************************/
165
166 /*
167 * @implemented
168 */
169 VOID
170 NTAPI
171 HalCalibratePerformanceCounter(IN volatile PLONG Count,
172 IN ULONGLONG NewCount)
173 {
174 ULONG_PTR Flags;
175
176 /* Disable interrupts */
177 Flags = __readeflags();
178 _disable();
179
180 /* Do a decrement for this CPU */
181 _InterlockedDecrement(Count);
182
183 /* Wait for other CPUs */
184 while (*Count);
185
186 /* Restore interrupts if they were previously enabled */
187 __writeeflags(Flags);
188 }
189
190 /*
191 * @implemented
192 */
193 ULONG
194 NTAPI
195 HalSetTimeIncrement(IN ULONG Increment)
196 {
197 /* Round increment to ms */
198 Increment /= 10000;
199
200 /* Normalize between our minimum (1 ms) and maximum (variable) setting */
201 if (Increment > HalpLargestClockMS) Increment = HalpLargestClockMS;
202 if (Increment <= 0) Increment = 1;
203
204 /* Set the rate and tell HAL we want to change it */
205 HalpNextMSRate = Increment;
206 HalpClockSetMSRate = TRUE;
207
208 /* Return the increment */
209 return HalpRolloverTable[Increment - 1].HighPart;
210 }
211
212 /* EOF */