Thunk.c@ 85788

Last change on this file since 85788 was 85718, checked in by vboxsync, 5 years ago
Devices/EFI: Merge edk-stable202005 and make it build, bugref:4643
Property svn:eol-style set to `native`
File size: 12.5 KB

Line
1	/** @file
2	Call into 16-bit BIOS code, Use AsmThunk16 function of BaseLib.
3
4	Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
5
6	SPDX-License-Identifier: BSD-2-Clause-Patent
7
8	**/
9
10	#include "LegacyBiosInterface.h"
11
12	THUNK_CONTEXT mThunkContext;
13
14	/**
15	Sets the counter value for Timer #0 in a legacy 8254 timer.
16
17	@param Count - The 16-bit counter value to program into Timer #0 of the legacy 8254 timer.
18
19	**/
20	VOID
21	SetPitCount (
22	IN UINT16 Count
23	)
24	{
25	IoWrite8 (TIMER_CONTROL_PORT, TIMER0_CONTROL_WORD);
26	IoWrite8 (TIMER0_COUNT_PORT, (UINT8) (Count & 0xFF));
27	IoWrite8 (TIMER0_COUNT_PORT, (UINT8) ((Count>>8) & 0xFF));
28	}
29
30	/**
31	Thunk to 16-bit real mode and execute a software interrupt with a vector
32	of BiosInt. Regs will contain the 16-bit register context on entry and
33	exit.
34
35	@param This Protocol instance pointer.
36	@param BiosInt Processor interrupt vector to invoke
37	@param Regs Register contexted passed into (and returned) from thunk to
38	16-bit mode
39
40	@retval FALSE Thunk completed, and there were no BIOS errors in the target code.
41	See Regs for status.
42	@retval TRUE There was a BIOS erro in the target code.
43
44	**/
45	BOOLEAN
46	EFIAPI
47	LegacyBiosInt86 (
48	IN EFI_LEGACY_BIOS_PROTOCOL *This,
49	IN UINT8 BiosInt,
50	IN EFI_IA32_REGISTER_SET *Regs
51	)
52	{
53	UINT16 Segment;
54	UINT16 Offset;
55
56	Regs->X.Flags.Reserved1 = 1;
57	Regs->X.Flags.Reserved2 = 0;
58	Regs->X.Flags.Reserved3 = 0;
59	Regs->X.Flags.Reserved4 = 0;
60	Regs->X.Flags.IOPL = 3;
61	Regs->X.Flags.NT = 0;
62	Regs->X.Flags.IF = 0;
63	Regs->X.Flags.TF = 0;
64	Regs->X.Flags.CF = 0;
65	//
66	// The base address of legacy interrupt vector table is 0.
67	// We use this base address to get the legacy interrupt handler.
68	//
69	ACCESS_PAGE0_CODE (
70	Segment = (UINT16)(((UINT32 *)0)[BiosInt] >> 16);
71	Offset = (UINT16)((UINT32 *)0)[BiosInt];
72	);
73
74	return InternalLegacyBiosFarCall (
75	This,
76	Segment,
77	Offset,
78	Regs,
79	&Regs->X.Flags,
80	sizeof (Regs->X.Flags)
81	);
82	}
83
84	/**
85	Thunk to 16-bit real mode and call Segment:Offset. Regs will contain the
86	16-bit register context on entry and exit. Arguments can be passed on
87	the Stack argument
88
89	@param This Protocol instance pointer.
90	@param Segment Segemnt of 16-bit mode call
91	@param Offset Offset of 16-bit mdoe call
92	@param Regs Register contexted passed into (and returned) from
93	thunk to 16-bit mode
94	@param Stack Caller allocated stack used to pass arguments
95	@param StackSize Size of Stack in bytes
96
97	@retval FALSE Thunk completed, and there were no BIOS errors in
98	the target code. See Regs for status.
99	@retval TRUE There was a BIOS erro in the target code.
100
101	**/
102	BOOLEAN
103	EFIAPI
104	LegacyBiosFarCall86 (
105	IN EFI_LEGACY_BIOS_PROTOCOL *This,
106	IN UINT16 Segment,
107	IN UINT16 Offset,
108	IN EFI_IA32_REGISTER_SET *Regs,
109	IN VOID *Stack,
110	IN UINTN StackSize
111	)
112	{
113	Regs->X.Flags.Reserved1 = 1;
114	Regs->X.Flags.Reserved2 = 0;
115	Regs->X.Flags.Reserved3 = 0;
116	Regs->X.Flags.Reserved4 = 0;
117	Regs->X.Flags.IOPL = 3;
118	Regs->X.Flags.NT = 0;
119	Regs->X.Flags.IF = 1;
120	Regs->X.Flags.TF = 0;
121	Regs->X.Flags.CF = 0;
122
123	return InternalLegacyBiosFarCall (This, Segment, Offset, Regs, Stack, StackSize);
124	}
125
126	/**
127	Provide NULL interrupt handler which is used to check
128	if there is more than one HW interrupt registers with the CPU AP.
129
130	@param InterruptType - The type of interrupt that occurred
131	@param SystemContext - A pointer to the system context when the interrupt occurred
132
133	**/
134	VOID
135	EFIAPI
136	LegacyBiosNullInterruptHandler (
137	IN EFI_EXCEPTION_TYPE InterruptType,
138	IN EFI_SYSTEM_CONTEXT SystemContext
139	)
140	{
141	}
142
143	/**
144	Thunk to 16-bit real mode and call Segment:Offset. Regs will contain the
145	16-bit register context on entry and exit. Arguments can be passed on
146	the Stack argument
147
148	@param This Protocol instance pointer.
149	@param Segment Segemnt of 16-bit mode call
150	@param Offset Offset of 16-bit mdoe call
151	@param Regs Register contexted passed into (and returned) from thunk to
152	16-bit mode
153	@param Stack Caller allocated stack used to pass arguments
154	@param StackSize Size of Stack in bytes
155
156	@retval FALSE Thunk completed, and there were no BIOS errors in the target code.
157	See Regs for status.
158	@retval TRUE There was a BIOS erro in the target code.
159
160	**/
161	BOOLEAN
162	EFIAPI
163	InternalLegacyBiosFarCall (
164	IN EFI_LEGACY_BIOS_PROTOCOL *This,
165	IN UINT16 Segment,
166	IN UINT16 Offset,
167	IN EFI_IA32_REGISTER_SET *Regs,
168	IN VOID *Stack,
169	IN UINTN StackSize
170	)
171	{
172	UINTN Status;
173	LEGACY_BIOS_INSTANCE *Private;
174	UINT16 *Stack16;
175	EFI_TPL OriginalTpl;
176	IA32_REGISTER_SET ThunkRegSet;
177	BOOLEAN InterruptState;
178	UINT64 TimerPeriod;
179
180	Private = LEGACY_BIOS_INSTANCE_FROM_THIS (This);
181
182	ZeroMem (&ThunkRegSet, sizeof (ThunkRegSet));
183	ThunkRegSet.X.DI = Regs->X.DI;
184	ThunkRegSet.X.SI = Regs->X.SI;
185	ThunkRegSet.X.BP = Regs->X.BP;
186	ThunkRegSet.X.BX = Regs->X.BX;
187	ThunkRegSet.X.DX = Regs->X.DX;
188	//
189	// Sometimes, ECX is used to pass in 32 bit data. For example, INT 1Ah, AX = B10Dh is
190	// "PCI BIOS v2.0c + Write Configuration DWORD" and ECX has the dword to write.
191	//
192	ThunkRegSet.E.ECX = Regs->E.ECX;
193	ThunkRegSet.X.AX = Regs->X.AX;
194	ThunkRegSet.E.DS = Regs->X.DS;
195	ThunkRegSet.E.ES = Regs->X.ES;
196
197	CopyMem (&(ThunkRegSet.E.EFLAGS.UintN), &(Regs->X.Flags), sizeof (Regs->X.Flags));
198
199	//
200	// Clear the error flag; thunk code may set it. Stack16 should be the high address
201	// Make Statk16 address the low 16 bit must be not zero.
202	//
203	Stack16 = (UINT16 )((UINT8 ) mThunkContext.RealModeBuffer + mThunkContext.RealModeBufferSize - sizeof (UINT16));
204
205	//
206	// Save current rate of DXE Timer
207	//
208	Private->Timer->GetTimerPeriod (Private->Timer, &TimerPeriod);
209
210	//
211	// Disable DXE Timer while executing in real mode
212	//
213	Private->Timer->SetTimerPeriod (Private->Timer, 0);
214
215	//
216	// Save and disable interrupt of debug timer
217	//
218	InterruptState = SaveAndSetDebugTimerInterrupt (FALSE);
219
220	//
221	// The call to Legacy16 is a critical section to EFI
222	//
223	OriginalTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);
224
225	//
226	// Check to see if there is more than one HW interrupt registers with the CPU AP.
227	// If there is, then ASSERT() since that is not compatible with the CSM because
228	// interupts other than the Timer interrupt that was disabled above can not be
229	// handled properly from real mode.
230	//
231	DEBUG_CODE (
232	UINTN Vector;
233	UINTN Count;
234
235	for (Vector = 0x20, Count = 0; Vector < 0x100; Vector++) {
236	Status = Private->Cpu->RegisterInterruptHandler (Private->Cpu, Vector, LegacyBiosNullInterruptHandler);
237	if (Status == EFI_ALREADY_STARTED) {
238	Count++;
239	}
240	if (Status == EFI_SUCCESS) {
241	Private->Cpu->RegisterInterruptHandler (Private->Cpu, Vector, NULL);
242	}
243	}
244	if (Count >= 2) {
245	DEBUG ((DEBUG_ERROR, "ERROR: More than one HW interrupt active with CSM enabled\n"));
246	}
247	ASSERT (Count < 2);
248	);
249
250	//
251	// If the Timer AP has enabled the 8254 timer IRQ and the current 8254 timer
252	// period is less than the CSM required rate of 54.9254, then force the 8254
253	// PIT counter to 0, which is the CSM required rate of 54.9254 ms
254	//
255	if (Private->TimerUses8254 && TimerPeriod < 549254) {
256	SetPitCount (0);
257	}
258
259	if (Stack != NULL && StackSize != 0) {
260	//
261	// Copy Stack to low memory stack
262	//
263	Stack16 -= StackSize / sizeof (UINT16);
264	CopyMem (Stack16, Stack, StackSize);
265	}
266
267	ThunkRegSet.E.SS = (UINT16) (((UINTN) Stack16 >> 16) << 12);
268	ThunkRegSet.E.ESP = (UINT16) (UINTN) Stack16;
269	ThunkRegSet.E.CS = Segment;
270	ThunkRegSet.E.Eip = Offset;
271
272	mThunkContext.RealModeState = &ThunkRegSet;
273
274	//
275	// Set Legacy16 state. 0x08, 0x70 is legacy 8259 vector bases.
276	//
277	Status = Private->Legacy8259->SetMode (Private->Legacy8259, Efi8259LegacyMode, NULL, NULL);
278	ASSERT_EFI_ERROR (Status);
279
280	AsmThunk16 (&mThunkContext);
281
282	if (Stack != NULL && StackSize != 0) {
283	//
284	// Copy low memory stack to Stack
285	//
286	CopyMem (Stack, Stack16, StackSize);
287	}
288
289	//
290	// Restore protected mode interrupt state
291	//
292	Status = Private->Legacy8259->SetMode (Private->Legacy8259, Efi8259ProtectedMode, NULL, NULL);
293	ASSERT_EFI_ERROR (Status);
294
295	mThunkContext.RealModeState = NULL;
296
297	//
298	// Enable and restore rate of DXE Timer
299	//
300	Private->Timer->SetTimerPeriod (Private->Timer, TimerPeriod);
301
302	//
303	// End critical section
304	//
305	gBS->RestoreTPL (OriginalTpl);
306
307	//
308	// OPROM may allocate EBDA range by itself and change EBDA base and EBDA size.
309	// Get the current EBDA base address, and compared with pre-allocate minimum
310	// EBDA base address, if the current EBDA base address is smaller, it indicates
311	// PcdEbdaReservedMemorySize should be adjusted to larger for more OPROMs.
312	//
313	DEBUG_CODE (
314	{
315	UINTN EbdaBaseAddress;
316	UINTN ReservedEbdaBaseAddress;
317
318	ACCESS_PAGE0_CODE (
319	EbdaBaseAddress = ((UINT16 ) (UINTN) 0x40E) << 4;
320	ReservedEbdaBaseAddress = CONVENTIONAL_MEMORY_TOP
321	- PcdGet32 (PcdEbdaReservedMemorySize);
322	ASSERT (ReservedEbdaBaseAddress <= EbdaBaseAddress);
323	);
324	}
325	);
326
327	//
328	// Restore interrupt of debug timer
329	//
330	SaveAndSetDebugTimerInterrupt (InterruptState);
331
332	Regs->E.EDI = ThunkRegSet.E.EDI;
333	Regs->E.ESI = ThunkRegSet.E.ESI;
334	Regs->E.EBP = ThunkRegSet.E.EBP;
335	Regs->E.EBX = ThunkRegSet.E.EBX;
336	Regs->E.EDX = ThunkRegSet.E.EDX;
337	Regs->E.ECX = ThunkRegSet.E.ECX;
338	Regs->E.EAX = ThunkRegSet.E.EAX;
339	Regs->X.SS = ThunkRegSet.E.SS;
340	Regs->X.CS = ThunkRegSet.E.CS;
341	Regs->X.DS = ThunkRegSet.E.DS;
342	Regs->X.ES = ThunkRegSet.E.ES;
343
344	CopyMem (&(Regs->X.Flags), &(ThunkRegSet.E.EFLAGS.UintN), sizeof (Regs->X.Flags));
345
346	return (BOOLEAN) (Regs->X.Flags.CF == 1);
347	}
348
349	/**
350	Allocate memory < 1 MB and copy the thunker code into low memory. Se up
351	all the descriptors.
352
353	@param Private Private context for Legacy BIOS
354
355	@retval EFI_SUCCESS Should only pass.
356
357	**/
358	EFI_STATUS
359	LegacyBiosInitializeThunk (
360	IN LEGACY_BIOS_INSTANCE *Private
361	)
362	{
363	EFI_STATUS Status;
364	EFI_PHYSICAL_ADDRESS MemoryAddress;
365	UINT8 TimerVector;
366
367	MemoryAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) Private->IntThunk;
368
369	mThunkContext.RealModeBuffer = (VOID ) (UINTN) (MemoryAddress + ((sizeof (LOW_MEMORY_THUNK) / EFI_PAGE_SIZE) + 1) EFI_PAGE_SIZE);
370	mThunkContext.RealModeBufferSize = EFI_PAGE_SIZE;
371	mThunkContext.ThunkAttributes = THUNK_ATTRIBUTE_BIG_REAL_MODE \| THUNK_ATTRIBUTE_DISABLE_A20_MASK_INT_15;
372
373	AsmPrepareThunk16 (&mThunkContext);
374
375	//
376	// Get the interrupt vector number corresponding to IRQ0 from the 8259 driver
377	//
378	TimerVector = 0;
379	Status = Private->Legacy8259->GetVector (Private->Legacy8259, Efi8259Irq0, &TimerVector);
380	ASSERT_EFI_ERROR (Status);
381
382	//
383	// Check to see if the Timer AP has hooked the IRQ0 from the 8254 PIT
384	//
385	Status = Private->Cpu->RegisterInterruptHandler (
386	Private->Cpu,
387	TimerVector,
388	LegacyBiosNullInterruptHandler
389	);
390	if (Status == EFI_SUCCESS) {
391	//
392	// If the Timer AP has not enabled the 8254 timer IRQ, then force the 8254 PIT
393	// counter to 0, which is the CSM required rate of 54.9254 ms
394	//
395	Private->Cpu->RegisterInterruptHandler (
396	Private->Cpu,
397	TimerVector,
398	NULL
399	);
400	SetPitCount (0);
401
402	//
403	// Save status that the Timer AP is not using the 8254 PIT
404	//
405	Private->TimerUses8254 = FALSE;
406	} else if (Status == EFI_ALREADY_STARTED) {
407	//
408	// Save status that the Timer AP is using the 8254 PIT
409	//
410	Private->TimerUses8254 = TRUE;
411	} else {
412	//
413	// Unexpected status from CPU AP RegisterInterruptHandler()
414	//
415	ASSERT (FALSE);
416	}
417
418	return EFI_SUCCESS;
419	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/OvmfPkg/Csm/LegacyBiosDxe/Thunk.c@ 85788

Download in other formats: