Add some helpful debug output to LAYOUT parsing, and enable DoLAYOUT code. The tool...
[reactos.git] / reactos / hal / halx86 / generic / bios.c
1 /*
2 * PROJECT: ReactOS HAL
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: hal/halx86/generic/bios.c
5 * PURPOSE: BIOS Access 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 UCHAR HalpIopmSaveBuffer[0x2000];
18 ULONG HalpSavedPfn;
19 HARDWARE_PTE HalpSavedPte;
20 ULONG HalpGpfHandler;
21 ULONG HalpBopHandler;
22 USHORT HalpSavedIopmBase;
23 PUCHAR HalpSavedIoMap;
24 ULONG HalpSavedEsp0;
25
26 #define GetPdeAddress(x) (PHARDWARE_PTE)(((((ULONG_PTR)(x)) >> 22) << 2) + 0xC0300000)
27 #define GetPteAddress(x) (PHARDWARE_PTE)(((((ULONG_PTR)(x)) >> 12) << 2) + 0xC0000000)
28
29 /* FUNCTIONS ******************************************************************/
30
31 VOID
32 NTAPI
33 HalpStoreAndClearIopm(IN PUCHAR IoMap)
34 {
35 ULONG i;
36
37 /* Backup the old I/O Map */
38 RtlCopyMemory(HalpIopmSaveBuffer, IoMap, 0x2000);
39
40 /* Erase the current one */
41 for (i = 0; i < 0x2000; i++) IoMap[i] = 0;
42 for (i = 0x2000; i < 0x2004; i++) IoMap[i] = 0xFF;
43 }
44
45 VOID
46 NTAPI
47 HalpRestoreIopm(IN PUCHAR IoMap)
48 {
49 ULONG i;
50
51 /* Restore the backed up copy, and initialize it */
52 RtlCopyMemory(IoMap, HalpIopmSaveBuffer, 0x2000);
53 for (i = 0x2000; i < 0x2004; i++) IoMap[i] = 0xFF;
54 }
55
56 VOID
57 NTAPI
58 HalpMapRealModeMemory(VOID)
59 {
60 PHARDWARE_PTE Pte, V86Pte;
61 ULONG i;
62
63 /* Get the page table directory for the lowest meg of memory */
64 Pte = GetPdeAddress(0);
65 HalpSavedPfn = Pte->PageFrameNumber;
66 HalpSavedPte = *Pte;
67
68 /* Map it to the HAL reserved region and make it valid */
69 Pte->Valid = 1;
70 Pte->Write = 1;
71 Pte->Owner = 1;
72 Pte->PageFrameNumber = (GetPdeAddress(0xFFC00000))->PageFrameNumber;
73
74 /* Flush the TLB by resetting CR3 */
75 __writecr3(__readcr3());
76
77 /* Now loop the first meg of memory */
78 for (i = 0; i < 0x100000; i += PAGE_SIZE)
79 {
80 /* Identity map it */
81 Pte = GetPteAddress((PVOID)i);
82 Pte->PageFrameNumber = i >> PAGE_SHIFT;
83 Pte->Valid = 1;
84 Pte->Write = 1;
85 Pte->Owner = 1;
86 }
87
88 /* Now get the entry for our real mode V86 code and the target */
89 Pte = GetPteAddress(0x20000);
90 V86Pte = GetPteAddress(&HalpRealModeStart);
91 do
92 {
93 /* Map the physical address into our real-mode region */
94 Pte->PageFrameNumber = V86Pte->PageFrameNumber;
95
96 /* Keep going until we've reached the end of our region */
97 Pte++;
98 V86Pte++;
99 } while (V86Pte <= GetPteAddress(&HalpRealModeEnd));
100
101 /* Flush the TLB by resetting CR3 */
102 __writecr3(__readcr3());
103 }
104
105 VOID
106 NTAPI
107 HalpSwitchToRealModeTrapHandlers(VOID)
108 {
109 ULONG Handler;
110 PHARDWARE_PTE IdtPte;
111
112 /* On i586, the first 7 entries of IDT are write-protected, unprotect them. */ // Nasty hto hack
113 if (KeGetCurrentPrcb()->CpuType == 5)
114 {
115 IdtPte = GetPteAddress(((PKIPCR)KeGetPcr())->IDT);
116 IdtPte->Write = 1;
117
118 /* Flush the TLB by resetting CR3 */
119 __writecr3(__readcr3());
120 }
121
122 /* Save the current Invalid Opcode and General Protection Fault Handlers */
123 HalpGpfHandler = ((((PKIPCR)KeGetPcr())->IDT[13].ExtendedOffset << 16) &
124 0xFFFF0000) |
125 (((PKIPCR)KeGetPcr())->IDT[13].Offset & 0xFFFF);
126 HalpBopHandler = ((((PKIPCR)KeGetPcr())->IDT[6].ExtendedOffset << 16) &
127 0xFFFF0000) |
128 (((PKIPCR)KeGetPcr())->IDT[6].Offset & 0xFFFF);
129
130 /* Now set our own GPF handler to handle exceptions while in real mode */
131 Handler = (ULONG_PTR)HalpTrap0D;
132 ((PKIPCR)KeGetPcr())->IDT[13].ExtendedOffset =
133 (USHORT)((Handler >> 16) & 0xFFFF);
134 ((PKIPCR)KeGetPcr())->IDT[13].Offset = (USHORT)Handler;
135
136 /* And our own invalid opcode handler to detect the BOP to get us out */
137 Handler = (ULONG_PTR)HalpTrap06;
138 ((PKIPCR)KeGetPcr())->IDT[6].ExtendedOffset =
139 (USHORT)((Handler >> 16) & 0xFFFF);
140 ((PKIPCR)KeGetPcr())->IDT[6].Offset = (USHORT)Handler;
141 }
142
143 VOID
144 NTAPI
145 HalpSetupRealModeIoPermissionsAndTask(VOID)
146 {
147 /* Save a copy of the I/O Map and delete it */
148 HalpSavedIoMap = (PUCHAR)&(KeGetPcr()->TSS->IoMaps[0]);
149 HalpStoreAndClearIopm(HalpSavedIoMap);
150
151 /* Save the IOPM and switch to the real-mode one */
152 HalpSavedIopmBase = KeGetPcr()->TSS->IoMapBase;
153 KeGetPcr()->TSS->IoMapBase = KiComputeIopmOffset(1);
154
155 /* Save our stack pointer */
156 HalpSavedEsp0 = KeGetPcr()->TSS->Esp0;
157 }
158
159 VOID
160 NTAPI
161 HalpRestoreTrapHandlers(VOID)
162 {
163 /* We're back, restore the handlers we over-wrote */
164 ((PKIPCR)KeGetPcr())->IDT[13].ExtendedOffset =
165 (USHORT)((HalpGpfHandler >> 16) & 0xFFFF);
166 ((PKIPCR)KeGetPcr())->IDT[13].Offset = (USHORT)HalpGpfHandler;
167 ((PKIPCR)KeGetPcr())->IDT[6].ExtendedOffset =
168 (USHORT)((HalpBopHandler >> 16) & 0xFFFF);
169 ((PKIPCR)KeGetPcr())->IDT[6].Offset = (USHORT)HalpBopHandler;
170 }
171
172 VOID
173 NTAPI
174 HalpRestoreIoPermissionsAndTask(VOID)
175 {
176 /* Restore the stack pointer */
177 KeGetPcr()->TSS->Esp0 = HalpSavedEsp0;
178
179 /* Restore the I/O Map */
180 HalpRestoreIopm(HalpSavedIoMap);
181
182 /* Restore the IOPM */
183 KeGetPcr()->TSS->IoMapBase = HalpSavedIopmBase;
184 }
185
186 VOID
187 NTAPI
188 HalpUnmapRealModeMemory(VOID)
189 {
190 ULONG i;
191 PHARDWARE_PTE Pte;
192
193 /* Loop the first meg of memory */
194 for (i = 0; i < 0x100000; i += PAGE_SIZE)
195 {
196 /* Invalidate each PTE */
197 Pte = GetPteAddress((PVOID)i);
198 Pte->Valid = 0;
199 Pte->Write = 0;
200 //Pte->Owner = 0; // Missing this?
201 Pte->PageFrameNumber = 0;
202 }
203
204 /* Restore the PDE for the lowest megabyte of memory */
205 Pte = GetPdeAddress(0);
206 *Pte = HalpSavedPte;
207 Pte->PageFrameNumber = HalpSavedPfn;
208
209 /* Flush the TLB by resetting CR3 */
210 __writecr3(__readcr3());
211 }
212
213 BOOLEAN
214 NTAPI
215 HalpBiosDisplayReset(VOID)
216 {
217 ULONG Flags;
218
219 /* Disable interrupts */
220 Flags = __readeflags();
221 _disable();
222
223 /* Map memory available to the V8086 real-mode code */
224 HalpMapRealModeMemory();
225
226 /* Use special invalid opcode and GPF trap handlers */
227 HalpSwitchToRealModeTrapHandlers();
228
229 /* Configure the IOPM and TSS */
230 HalpSetupRealModeIoPermissionsAndTask();
231
232 /* Now jump to real mode */
233 HalpBiosCall();
234
235 /* Restore kernel trap handlers */
236 HalpRestoreTrapHandlers();
237
238 /* Restore TSS and IOPM */
239 HalpRestoreIoPermissionsAndTask();
240
241 /* Restore low memory mapping */
242 HalpUnmapRealModeMemory();
243
244 /* Restore interrupts if they were previously enabled */
245 __writeeflags(Flags);
246 return TRUE;
247 }
248
249 /* EOF */