blob: 1fd3f004c3999f1d5b90e502be984be5a33846c8 [file] [log] [blame]
Simon Glass1aa5e932015-08-04 12:34:05 -06001#
2# Copyright (C) 2015 Google, Inc
3#
4# SPDX-License-Identifier: GPL-2.0+
5#
6
Alexander Graf996a18a2016-03-04 01:10:09 +01007=========== Table of Contents ===========
8
9 1 U-Boot on EFI
10 1.1 In God's Name, Why?
11 1.2 Status
12 1.3 Build Instructions
13 1.4 Trying it out
14 1.5 Inner workings
15 1.6 EFI Application
16 1.7 EFI Payload
17 1.8 Tables
18 1.9 Interrupts
19 1.10 32/64-bit
20 1.11 Future work
21 1.12 Where is the code?
22
23 2 EFI on U-Boot
24 2.1 In God's Name, Why?
25 2.2 How do I get it?
26 2.3 Status
27 2.4 Future work
28
Simon Glass1aa5e932015-08-04 12:34:05 -060029U-Boot on EFI
30=============
31This document provides information about U-Boot running on top of EFI, either
32as an application or just as a means of getting U-Boot onto a new platform.
33
34
35In God's Name, Why?
36-------------------
37This is useful in several situations:
38
39- You have EFI running on a board but U-Boot does not natively support it
40fully yet. You can boot into U-Boot from EFI and use that until U-Boot is
41fully ported
42
43- You need to use an EFI implementation (e.g. UEFI) because your vendor
44requires it in order to provide support
45
46- You plan to use coreboot to boot into U-Boot but coreboot support does
47not currently exist for your platform. In the meantime you can use U-Boot
48on EFI and then move to U-Boot on coreboot when ready
49
50- You use EFI but want to experiment with a simpler alternative like U-Boot
51
52
53Status
54------
55Only x86 is supported at present. If you are using EFI on another architecture
56you may want to reconsider. However, much of the code is generic so could be
57ported.
58
59U-Boot supports running as an EFI application for 32-bit EFI only. This is
60not very useful since only a serial port is provided. You can look around at
61memory and type 'help' but that is about it.
62
63More usefully, U-Boot supports building itself as a payload for either 32-bit
64or 64-bit EFI. U-Boot is packaged up and loaded in its entirety by EFI. Once
65started, U-Boot changes to 32-bit mode (currently) and takes over the
66machine. You can use devices, boot a kernel, etc.
67
68
69Build Instructions
70------------------
71First choose a board that has EFI support and obtain an EFI implementation
Bin Meng7a867602015-08-17 20:34:47 -070072for that board. It will be either 32-bit or 64-bit. Alternatively, you can
73opt for using QEMU [1] and the OVMF [2], as detailed below.
Simon Glass1aa5e932015-08-04 12:34:05 -060074
Bin Meng7a867602015-08-17 20:34:47 -070075To build U-Boot as an EFI application (32-bit EFI required), enable CONFIG_EFI
76and CONFIG_EFI_APP. The efi-x86 config (efi-x86_defconfig) is set up for this.
77Just build U-Boot as normal, e.g.
Simon Glass1aa5e932015-08-04 12:34:05 -060078
Bin Meng7a867602015-08-17 20:34:47 -070079 make efi-x86_defconfig
Simon Glass1aa5e932015-08-04 12:34:05 -060080 make
81
Bin Meng7a867602015-08-17 20:34:47 -070082To build U-Boot as an EFI payload (32-bit or 64-bit EFI can be used), adjust an
83existing config (like qemu-x86_defconfig) to enable CONFIG_EFI, CONFIG_EFI_STUB
84and either CONFIG_EFI_STUB_32BIT or CONFIG_EFI_STUB_64BIT. All of these are
85boolean Kconfig options. Then build U-Boot as normal, e.g.
86
87 make qemu-x86_defconfig
88 make
89
90You will end up with one of these files depending on what you build for:
Simon Glass1aa5e932015-08-04 12:34:05 -060091
92 u-boot-app.efi - U-Boot EFI application
93 u-boot-payload.efi - U-Boot EFI payload application
94
95
96Trying it out
97-------------
Bin Meng7a867602015-08-17 20:34:47 -070098QEMU is an emulator and it can emulate an x86 machine. Please make sure your
99QEMU version is 2.3.0 or above to test this. You can run the payload with
100something like this:
Simon Glass1aa5e932015-08-04 12:34:05 -0600101
102 mkdir /tmp/efi
103 cp /path/to/u-boot*.efi /tmp/efi
104 qemu-system-x86_64 -bios bios.bin -hda fat:/tmp/efi/
105
106Add -nographic if you want to use the terminal for output. Once it starts
107type 'fs0:u-boot-payload.efi' to run the payload or 'fs0:u-boot-app.efi' to
Bin Meng7a867602015-08-17 20:34:47 -0700108run the application. 'bios.bin' is the EFI 'BIOS'. Check [2] to obtain a
109prebuilt EFI BIOS for QEMU or you can build one from source as well.
Simon Glass1aa5e932015-08-04 12:34:05 -0600110
111To try it on real hardware, put u-boot-app.efi on a suitable boot medium,
112such as a USB stick. Then you can type something like this to start it:
113
114 fs0:u-boot-payload.efi
115
116(or fs0:u-boot-app.efi for the application)
117
118This will start the payload, copy U-Boot into RAM and start U-Boot. Note
119that EFI does not support booting a 64-bit application from a 32-bit
120EFI (or vice versa). Also it will often fail to print an error message if
121you get this wrong.
122
123
124Inner workings
125==============
126Here follow a few implementation notes for those who want to fiddle with
127this and perhaps contribute patches.
128
129The application and payload approaches sound similar but are in fact
130implemented completely differently.
131
132EFI Application
133---------------
134For the application the whole of U-Boot is built as a shared library. The
135efi_main() function is in lib/efi/efi_app.c. It sets up some basic EFI
136functions with efi_init(), sets up U-Boot global_data, allocates memory for
137U-Boot's malloc(), etc. and enters the normal init sequence (board_init_f()
138and board_init_r()).
139
140Since U-Boot limits its memory access to the allocated regions very little
141special code is needed. The CONFIG_EFI_APP option controls a few things
142that need to change so 'git grep CONFIG_EFI_APP' may be instructive.
143The CONFIG_EFI option controls more general EFI adjustments.
144
145The only available driver is the serial driver. This calls back into EFI
146'boot services' to send and receive characters. Although it is implemented
147as a serial driver the console device is not necessarilly serial. If you
148boot EFI with video output then the 'serial' device will operate on your
149target devices's display instead and the device's USB keyboard will also
150work if connected. If you have both serial and video output, then both
151consoles will be active. Even though U-Boot does the same thing normally,
152These are features of EFI, not U-Boot.
153
154Very little code is involved in implementing the EFI application feature.
155U-Boot is highly portable. Most of the difficulty is in modifying the
156Makefile settings to pass the right build flags. In particular there is very
157little x86-specific code involved - you can find most of it in
158arch/x86/cpu. Porting to ARM (which can also use EFI if you are brave
159enough) should be straightforward.
160
161Use the 'reset' command to get back to EFI.
162
163EFI Payload
164-----------
165The payload approach is a different kettle of fish. It works by building
166U-Boot exactly as normal for your target board, then adding the entire
167image (including device tree) into a small EFI stub application responsible
168for booting it. The stub application is built as a normal EFI application
169except that it has a lot of data attached to it.
170
171The stub application is implemented in lib/efi/efi_stub.c. The efi_main()
172function is called by EFI. It is responsible for copying U-Boot from its
173original location into memory, disabling EFI boot services and starting
174U-Boot. U-Boot then starts as normal, relocates, starts all drivers, etc.
175
176The stub application is architecture-dependent. At present it has some
177x86-specific code and a comment at the top of efi_stub.c describes this.
178
179While the stub application does allocate some memory from EFI this is not
180used by U-Boot (the payload). In fact when U-Boot starts it has all of the
181memory available to it and can operate as it pleases (but see the next
182section).
183
184Tables
185------
186The payload can pass information to U-Boot in the form of EFI tables. At
187present this feature is used to pass the EFI memory map, an inordinately
188large list of memory regions. You can use the 'efi mem all' command to
189display this list. U-Boot uses the list to work out where to relocate
190itself.
191
192Although U-Boot can use any memory it likes, EFI marks some memory as used
193by 'run-time services', code that hangs around while U-Boot is running and
194is even present when Linux is running. This is common on x86 and provides
195a way for Linux to call back into the firmware to control things like CPU
196fan speed. U-Boot uses only 'conventional' memory, in EFI terminology. It
197will relocate itself to the top of the largest block of memory it can find
198below 4GB.
199
200Interrupts
201----------
202U-Boot drivers typically don't use interrupts. Since EFI enables interrupts
203it is possible that an interrupt will fire that U-Boot cannot handle. This
204seems to cause problems. For this reason the U-Boot payload runs with
205interrupts disabled at present.
206
20732/64-bit
208---------
209While the EFI application can in principle be built as either 32- or 64-bit,
210only 32-bit is currently supported. This means that the application can only
211be used with 32-bit EFI.
212
213The payload stub can be build as either 32- or 64-bits. Only a small amount
214of code is built this way (see the extra- line in lib/efi/Makefile).
215Everything else is built as a normal U-Boot, so is always 32-bit on x86 at
216present.
217
218Future work
219-----------
220This work could be extended in a number of ways:
221
222- Add a generic x86 EFI payload configuration. At present you need to modify
223an existing one, but mostly the low-level x86 code is disabled when booting
224on EFI anyway, so a generic 'EFI' board could be created with a suitable set
225of drivers enabled.
226
227- Add ARM support
228
229- Add 64-bit application support
230
231- Figure out how to solve the interrupt problem
232
233- Add more drivers to the application side (e.g. video, block devices, USB,
234environment access). This would mostly be an academic exercise as a strong
235use case is not readily apparent, but it might be fun.
236
237- Avoid turning off boot services in the stub. Instead allow U-Boot to make
238use of boot services in case it wants to. It is unclear what it might want
239though.
240
241Where is the code?
242------------------
243lib/efi
244 payload stub, application, support code. Mostly arch-neutral
245
246arch/x86/lib/efi
247 helper functions for the fake DRAM init, etc. These can be used by
248 any board that runs as a payload.
249
250arch/x86/cpu/efi
251 x86 support code for running as an EFI application
252
253board/efi/efi-x86/efi.c
254 x86 board code for running as an EFI application
255
256common/cmd_efi.c
257 the 'efi' command
258
Simon Glass1aa5e932015-08-04 12:34:05 -0600259--
260Ben Stoltz, Simon Glass
261Google, Inc
262July 2015
Bin Meng7a867602015-08-17 20:34:47 -0700263
264[1] http://www.qemu.org
265[2] http://www.tianocore.org/ovmf/
Alexander Graf996a18a2016-03-04 01:10:09 +0100266
267-------------------------------------------------------------------------------
268
269EFI on U-Boot
270=============
271
272In addition to support for running U-Boot as a UEFI application, U-Boot itself
273can also expose the UEFI interfaces and thus allow UEFI payloads to run under
274it.
275
276In God's Name, Why?
277-------------------
278
279With this support in place, you can run any UEFI payload (such as the Linux
280kernel, grub2 or gummiboot) on U-Boot. This dramatically simplifies boot loader
281configuration, as U-Boot based systems now look and feel (almost) the same way
282as TianoCore based systems.
283
284How do I get it?
285----------------
286
287EFI support for 32bit ARM and AArch64 is already included in U-Boot. All you
288need to do is enable
289
290 CONFIG_CMD_BOOTEFI=y
291 CONFIG_EFI_LOADER=y
292
293in your .config file and you will automatically get a bootefi command to run
294an efi application as well as snippet in the default distro boot script that
295scans for removable media efi binaries as fallback.
296
297Status
298------
299
300I am successfully able to run grub2 and Linux EFI binaries with this code on
301ARMv7 as well as AArch64 systems.
302
303When enabled, the resulting U-Boot binary only grows by ~10KB, so it's very
304light weight.
305
306All storage devices are directly accessible from the uEFI payload
307
308Removable media booting (search for /efi/boot/boota{a64,arm}.efi) is supported.
309
310Simple use cases like "Plug this SD card into my ARM device and it just
311boots into grub which boots into Linux", work very well.
312
313Future work
314-----------
315
316Of course, there are still a few things one could do on top:
317
318 - Improve disk media detection (don't scan, use what information we
319have)
320 - Add EFI variable support using NVRAM
321 - Add GFX support
322 - Make EFI Shell work
323 - Network device support
324 - Support for payload exit
325 - Payload Watchdog support