Updated BaseLib for THUNK functions and some CPU functions
[mirror_edk2.git] / MdePkg / Library / BaseLib / x86Thunk.c
1 /** @file
2 Real Mode Thunk Functions for IA32 and X64.
3
4 Copyright (c) 2006, Intel Corporation<BR>
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 Module Name: x86Thunk.c
14
15 **/
16
17 //
18 // Byte packed structure for a segment descriptor in a GDT/LDT
19 //
20 typedef union {
21 struct {
22 UINT32 LimitLow:16;
23 UINT32 BaseLow:16;
24 UINT32 BaseMid:8;
25 UINT32 Type:4;
26 UINT32 S:1;
27 UINT32 DPL:2;
28 UINT32 P:1;
29 UINT32 LimitHigh:4;
30 UINT32 AVL:1;
31 UINT32 L:1;
32 UINT32 DB:1;
33 UINT32 G:1;
34 UINT32 BaseHigh:8;
35 } Bits;
36 UINT64 Uint64;
37 } IA32_SEGMENT_DESCRIPTOR;
38
39 extern CONST UINT8 m16Start;
40 extern CONST UINT16 m16Size;
41 extern CONST UINT16 mThunk16Attr;
42 extern CONST UINT16 m16Gdt;
43 extern CONST UINT16 m16GdtrBase;
44 extern CONST UINT16 mTransition;
45
46 /**
47 Invokes 16-bit code in big real mode and returns the updated register set.
48
49 This function transfers control to the 16-bit code specified by CS:EIP using
50 the stack specified by SS:ESP in RegisterSet. The updated registers are saved
51 on the real mode stack and the starting address of the save area is returned.
52
53 @param RegisterSet Values of registers before invocation of 16-bit code.
54 @param Transition Pointer to the transition code under 1MB.
55
56 @return The pointer to a IA32_REGISTER_SET structure containing the updated
57 register values.
58
59 **/
60 IA32_REGISTER_SET *
61 InternalAsmThunk16 (
62 IN IA32_REGISTER_SET *RegisterSet,
63 IN OUT VOID *Transition
64 );
65
66 /**
67 Retrieves the properties for 16-bit thunk functions.
68
69 Computes the size of the buffer and stack below 1MB required to use the
70 AsmPrepareThunk16(), AsmThunk16() and AsmPrepareAndThunk16() functions. This
71 buffer size is returned in RealModeBufferSize, and the stack size is returned
72 in ExtraStackSize. If parameters are passed to the 16-bit real mode code,
73 then the actual minimum stack size is ExtraStackSize plus the maximum number
74 of bytes that need to be passed to the 16-bit real mode code.
75
76 If RealModeBufferSize is NULL, then ASSERT().
77 If ExtraStackSize is NULL, then ASSERT().
78
79 @param RealModeBufferSize A pointer to the size of the buffer below 1MB
80 required to use the 16-bit thunk functions.
81 @param ExtraStackSize A pointer to the extra size of stack below 1MB
82 that the 16-bit thunk functions require for
83 temporary storage in the transition to and from
84 16-bit real mode.
85
86 **/
87 VOID
88 EFIAPI
89 AsmGetThunk16Properties (
90 OUT UINT32 *RealModeBufferSize,
91 OUT UINT32 *ExtraStackSize
92 )
93 {
94 ASSERT (RealModeBufferSize != NULL);
95 ASSERT (ExtraStackSize != NULL);
96
97 *RealModeBufferSize = m16Size;
98 *ExtraStackSize = sizeof (IA32_DWORD_REGS) + 8;
99 }
100
101 /**
102 Prepares all structures a code required to use AsmThunk16().
103
104 Prepares all structures and code required to use AsmThunk16().
105
106 If ThunkContext is NULL, then ASSERT().
107
108 @param ThunkContext A pointer to the context structure that describes the
109 16-bit real mode code to call.
110
111 **/
112 VOID
113 EFIAPI
114 AsmPrepareThunk16 (
115 OUT THUNK_CONTEXT *ThunkContext
116 )
117 {
118 IA32_SEGMENT_DESCRIPTOR *RealModeGdt;
119
120 ASSERT (ThunkContext != NULL);
121 ASSERT ((UINTN)ThunkContext->RealModeBuffer < 0x100000);
122 ASSERT (ThunkContext->RealModeBufferSize >= m16Size);
123 ASSERT ((UINTN)ThunkContext->RealModeBuffer + m16Size <= 0x100000);
124 ASSERT (((UINTN)ThunkContext->RealModeBuffer & 0x0f) == 0);
125
126 CopyMem (ThunkContext->RealModeBuffer, &m16Start, m16Size);
127
128 //
129 // Point RealModeGdt to the GDT to be used in transition
130 //
131 // RealModeGdt[0]: Reserved as NULL descriptor
132 // RealModeGdt[1]: Code Segment
133 // RealModeGdt[2]: Data Segment
134 // RealModeGdt[3]: Call Gate
135 //
136 RealModeGdt = (IA32_SEGMENT_DESCRIPTOR*)(
137 (UINTN)ThunkContext->RealModeBuffer + m16Gdt);
138
139 //
140 // Update Code & Data Segment Descriptor
141 //
142 RealModeGdt[1].Bits.BaseLow =
143 (UINT32)(UINTN)ThunkContext->RealModeBuffer & ~0xf;
144 RealModeGdt[1].Bits.BaseMid =
145 (UINT32)(UINTN)ThunkContext->RealModeBuffer >> 16;
146
147 //
148 // Update transition code entry point offset
149 //
150 *(UINT32*)((UINTN)ThunkContext->RealModeBuffer + mTransition) +=
151 (UINT32)(UINTN)ThunkContext->RealModeBuffer & 0xf;
152
153 //
154 // Update Segment Limits for both Code and Data Segment Descriptors
155 //
156 if ((ThunkContext->ThunkAttributes & THUNK_ATTRIBUTE_BIG_REAL_MODE) == 0) {
157 //
158 // Set segment limits to 64KB
159 //
160 RealModeGdt[1].Bits.LimitHigh = 0;
161 RealModeGdt[1].Bits.G = 0;
162 RealModeGdt[2].Bits.LimitHigh = 0;
163 RealModeGdt[2].Bits.G = 0;
164 }
165
166 //
167 // Update GDTBASE for this thunk context
168 //
169 *(VOID**)((UINTN)ThunkContext->RealModeBuffer + m16GdtrBase) = RealModeGdt;
170
171 //
172 // Update Thunk Attributes
173 //
174 *(UINT32*)((UINTN)ThunkContext->RealModeBuffer + mThunk16Attr) =
175 ThunkContext->ThunkAttributes;
176 }
177
178 /**
179 Transfers control to a 16-bit real mode entry point and returns the results.
180
181 Transfers control to a 16-bit real mode entry point and returns the results.
182 AsmPrepareThunk16() must be called with ThunkContext before this function is
183 used. This function must be called with interrupts disabled.
184
185 If ThunkContext is NULL, then ASSERT().
186 If AsmPrepareThunk16() was not previously called with ThunkContext, then ASSERT().
187
188 @param ThunkContext A pointer to the context structure that describes the
189 16-bit real mode code to call.
190
191 **/
192 VOID
193 EFIAPI
194 AsmThunk16 (
195 IN OUT THUNK_CONTEXT *ThunkContext
196 )
197 {
198 IA32_REGISTER_SET *UpdatedRegs;
199
200 ASSERT (ThunkContext != NULL);
201 ASSERT ((UINTN)ThunkContext->RealModeBuffer < 0x100000);
202 ASSERT (ThunkContext->RealModeBufferSize >= m16Size);
203 ASSERT ((UINTN)ThunkContext->RealModeBuffer + m16Size <= 0x100000);
204 ASSERT (((UINTN)ThunkContext->RealModeBuffer & 0x0f) == 0);
205
206 UpdatedRegs = InternalAsmThunk16 (
207 ThunkContext->RealModeState,
208 ThunkContext->RealModeBuffer
209 );
210
211 CopyMem (ThunkContext->RealModeState, UpdatedRegs, sizeof (*UpdatedRegs));
212 }
213
214 /**
215 Prepares all structures and code for a 16-bit real mode thunk, transfers
216 control to a 16-bit real mode entry point, and returns the results.
217
218 Prepares all structures and code for a 16-bit real mode thunk, transfers
219 control to a 16-bit real mode entry point, and returns the results. If the
220 caller only need to perform a single 16-bit real mode thunk, then this
221 service should be used. If the caller intends to make more than one 16-bit
222 real mode thunk, then it is more efficient if AsmPrepareThunk16() is called
223 once and AsmThunk16() can be called for each 16-bit real mode thunk. This
224 function must be called with interrupts disabled.
225
226 If ThunkContext is NULL, then ASSERT().
227
228 @param ThunkContext A pointer to the context structure that describes the
229 16-bit real mode code to call.
230
231 **/
232 VOID
233 EFIAPI
234 AsmPrepareAndThunk16 (
235 IN OUT THUNK_CONTEXT *ThunkContext
236 )
237 {
238 AsmPrepareThunk16 (ThunkContext);
239 AsmThunk16 (ThunkContext);
240 }