1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
|
The SeaBIOS code is required to support multiple x86 CPU memory
models. This requirement impacts the code layout and internal storage
of SeaBIOS.
x86 Memory Models
=================
The x86 line of CPUs has evolved over many years. The original 8086
chip used 16bit pointers and could only address 1 megabyte of memory.
The 80286 CPU still used 16bit pointers, but could address up to 16
megabytes of memory. The 80386 chips could process 32bit instructions
and could access up to 4 gigabyte of memory. The most recent x86 chips
can process 64bit instructions and access 16 exabytes of ram.
During the evolution of the x86 CPUs from the 8086 to the 80386 the
BIOS was extended to handle calls in the various modes that the CPU
implemented.
This section outlines the five different x86 CPU execution and memory
access models that SeaBIOS supports.
16bit real mode
---------------
This mode is a
[segmented](http://en.wikipedia.org/wiki/Memory_segmentation) memory
mode invoked by callers. The CPU defaults to executing 16bit
instructions. Callers typically invoke the BIOS by issuing an "int x"
instruction which causes a software
[interrupt](http://en.wikipedia.org/wiki/Interrupt) that is handled by
the BIOS. The SeaBIOS code also handles hardware interrupts in this
mode. SeaBIOS can only access the first 1 megabyte of memory in this
mode, but it can access any part of that first megabyte.
16bit bigreal mode
------------------
This mode is a segmented memory mode that is used for [option
roms](http://en.wikipedia.org/wiki/Option_ROM). The CPU defaults to
executing 16bit instructions and segmented memory accesses are still
used. However, the segment limits are increased so that the entire
first 4 gigabytes of memory is fully accessible. Callers can invoke
all the [16bit real mode](#16bit_real_mode) functions while in this
mode and can also invoke the Post Memory Manager (PMM) functions that
are available during option rom execution.
16bit protected mode
--------------------
CPU execution in this mode is similar to [16bit real
mode](#16bit_real_mode). The CPU defaults to executing 16bit
instructions. However, each segment register indexes a "descriptor
table", and it is difficult or impossible to know what the physical
address of each segment is. Generally speaking, the BIOS can only
access code and data in the f-segment. The PCIBIOS, APM BIOS, and PNP
BIOS all have documented 16bit protected mode entry points.
Some old code may attempt to invoke the standard [16bit real
mode](#16bit_real_mode) entry points while in 16bit protected
mode. The PCI BIOS specification explicitly requires that the legacy
"int 1a" real mode entry point support 16bit protected mode calls if
they are for the PCI BIOS. Callers of other legacy entry points in
protected mode have not been observed and SeaBIOS does not support
them.
32bit segmented mode
--------------------
In this mode the processor runs in 32bit mode, but the segment
registers may have a limit and may have a non-zero offset. In effect,
this mode has all of the limitations of [16bit protected
mode](#16bit_protected_mode) - the main difference between the modes
is that the processor defaults to executing 32bit instructions. In
addition to these limitations, callers may also run the SeaBIOS code
at varying virtual addresses and so the code must support code
relocation. The PCI BIOS specification and APM BIOS specification
define 32bit segmented mode interfaces.
32bit flat mode
---------------
In this mode the processor defaults to executing 32bit instructions,
and all segment registers have an offset of zero and allow access to
the entire first 4 gigabytes of memory. This is the only "sane" mode
for 32bit code - modern compilers and modern operating systems will
generally only support this mode (when running 32bit code).
Ironically, it's the only mode that is not strictly required for a
BIOS to support. SeaBIOS uses this mode internally to support the POST
and BOOT [phases of execution](Execution and code flow).
code16gcc
=========
In order to produce code that can run when the processor is in a 16bit
mode, SeaBIOS uses the
[binutils](http://en.wikipedia.org/wiki/GNU_Binutils) ".code16gcc"
assembler flag. This instructs the assembler to emit extra prefix
opcodes so that the 32bit code produced by
[gcc](http://en.wikipedia.org/wiki/GNU_Compiler_Collection) will run
even when the processor is in 16bit mode. Note that gcc always
produces 32bit code - it does not know about the ".code16gcc" flag and
does not know that the code will run in a 16bit mode.
SeaBIOS uses the same code for all of the 16bit modes ([16bit real
mode](#16bit_real_mode), [16bit bigreal mode](#16bit_bigreal_mode),
and [16bit protected mode](#16bit_protected_mode)) and that code is
assembled using ".code16gcc". SeaBIOS is careful to use segment
registers properly so that the same code can run in the different
16bit modes that it needs to support.
C code mode flags
=================
Two compile time flags are available to determine the memory model the
code is intended for: MODE16 and MODESEGMENT. When compiling for the
16 bit modes, MODE16 is true and MODESEGMENT is true. In 32bit
segmented mode, MODE16 is false and MODESEGMENT is true. In 32bit flat
mode both MODE16 and MODESEGMENT are false.
Common memory used at run-time
==============================
There are several memory areas that the SeaBIOS "runtime"
[phase](Execution and code flow) makes use of:
* 0x000000-0x000400: Interrupt descriptor table (IDT). This area
defines 256 interrupt vectors as defined by the Intel CPU
specification for 16bit irq handlers. This area is read/writable at
runtime and can be accessed from 16bit real mode and 16bit bigreal
mode calls. SeaBIOS only uses this area to maintain compatibility
with legacy systems.
* 0x000400-0x000500: BIOS Data Area (BDA). This area contains various
legacy flags and attributes. The area is read/writable at runtime
and can be accessed from 16bit real mode and 16bit bigreal mode
calls. SeaBIOS only uses this area to maintain compatibility with
legacy systems.
* 0x09FC00-0x0A0000 (typical): Extended BIOS Data Area (EBDA). This
area contains a few legacy flags and attributes. The area is
typically located at 0x9FC00, but it can be moved by option roms, by
legacy operating systems, and by SeaBIOS if
CONFIG_MALLOC_UPPERMEMORY is not set. Its actual location is
determined by a pointer in the BDA. The area is read/writable at
runtime and can be accessed from 16bit real mode and 16bit bigreal
mode calls. SeaBIOS only uses this area to maintain compatibility
with legacy systems.
* 0x0E0000-0x0F0000 (typical): "low" memory. This area is used for
custom read/writable storage internal to SeaBIOS. The area is
read/writable at runtime and can be accessed from 16bit real mode
and 16bit bigreal mode calls. The area is typically located at the
end of the e-segment, but the build may position it anywhere in the
0x0C0000-0x0F0000 region. However, if CONFIG_MALLOC_UPPERMEMORY is
not set, then this region is between 0x090000-0x0A0000. Space is
allocated in this region by either marking a global variable with
the "VARLOW" flag or by calling malloc_low() during
initialization. The area can be grown dynamically (via malloc_low),
but it will never exceed 64K.
* 0x0F0000-0x100000: The BIOS segment. This area is used for both
runtime code and static variables. Space is allocated in this region
by either marking a global variable with VAR16, one of the VARFSEG
flags, or by calling malloc_fseg() during initialization. The area
is read-only at runtime and can be accessed from 16bit real mode,
16bit bigreal mode, 16bit protected mode, and 32bit segmented mode
calls.
All of the above areas are also read/writable during the SeaBIOS
initialization phase and are accessible when in 32bit flat mode.
Segmented mode memory access
============================
The assembler entry functions for segmented mode calls (all modes
except [32bit flat mode](#32bit_flat_mode)) will arrange
to set the data segment (%ds) to be the same as the stack segment
(%ss) before calling any C code. This permits all C variables located
on the stack and C pointers to data located on the stack to work as
normal.
However, all code running in segmented mode must wrap non-stack memory
accesses in special macros. These macros ensure the correct segment
register is used. Failure to use the correct macro will result in an
incorrect memory access that will likely cause hard to find errors.
There are three low-level memory access macros:
* GET_VAR / SET_VAR : Accesses a variable using the specified segment
register. This isn't typically used directly by C code.
* GET_FARVAR / SET_FARVAR : Assigns the extra segment (%es) to the
given segment id and then performs the given memory access via %es.
* GET_FLATVAR / SET_FLATVAR : These macros take a 32bit pointer,
construct a segment/offset pair valid in real mode, and then perform
the given access. These macros must not be used in 16bit protected
mode or 32bit segmented mode.
Since most memory accesses are to [common memory used at
run-time](#Common_memory_used_at_run-time), several helper
macros are also available.
* GET_IDT / SET_IDT : Access the interrupt descriptor table (IDT).
* GET_BDA / SET_BDA : Access the BIOS Data Area (BDA).
* GET_EBDA / SET_EBDA : Access the Extended BIOS Data Area (EBDA).
* GET_LOW / SET_LOW : Access internal variables marked with
VARLOW. (There are also related macros GET_LOWFLAT / SET_LOWFLAT for
accessing storage allocated with malloc_low).
* GET_GLOBAL : Access internal variables marked with the VAR16 or
VARFSEG flags. (There is also the related macro GET_GLOBALFLAT for
accessing storage allocated with malloc_fseg).
Memory available during initialization
======================================
During the POST [phase](Execution and code flow) the code
can fully access the first 4 gigabytes of memory. However, memory
accesses are generally limited to the [common memory used at
run-time](#Common_memory_used_at_run-time) and areas
allocated at runtime via one of the malloc calls:
* malloc_high : Permanent high-memory zone. This area is used for
custom read/writable storage internal to SeaBIOS. The area is
located at the top of the first 4 gigabytes of ram. It is commonly
used for storing standard tables accessed by the operating system at
runtime (ACPI, SMBIOS, and MPTable) and for DMA buffers used by
hardware drivers. The area is read/writable at runtime and an entry
in the e820 memory map is used to reserve it. When running on an
emulator that has only 1 megabyte of ram this zone will be empty.
* malloc_tmphigh : Temporary high-memory zone. This area is used for
custom read/writable storage during the SeaBIOS initialization
phase. The area generally starts after the first 1 megabyte of ram
(0x100000) and ends prior to the Permanent high-memory zone. When
running on an emulator that has only 1 megabyte of ram this zone
will be empty. The area is not reserved from the operating system,
so it must not be accessed after the SeaBIOS initialization phase.
* malloc_tmplow : Temporary low-memory zone. This area is used for
custom read/writable storage during the SeaBIOS initialization
phase. The area resides between 0x07000-0x90000. The area is not
reserved from the operating system and by specification it is
required to be zero'd at the end of the initialization phase.
The "tmplow" and "tmphigh" regions are only available during the
initialization phase. Any access (either read or write) after
completion of the initialization phase can result in difficult to find
errors.
|
