xref: /openbmc/u-boot/doc/README.u-boot_on_efi (revision 21299d3a)
1# SPDX-License-Identifier: GPL-2.0+
2#
3# Copyright (C) 2015 Google, Inc
4
5U-Boot on EFI
6=============
7This document provides information about U-Boot running on top of EFI, either
8as an application or just as a means of getting U-Boot onto a new platform.
9
10
11=========== Table of Contents ===========
12
13Motivation
14Status
15Build Instructions
16Trying it out
17Inner workings
18EFI Application
19EFI Payload
20Tables
21Interrupts
2232/64-bit
23Future work
24Where is the code?
25
26
27Motivation
28----------
29Running U-Boot on EFI is useful in several situations:
30
31- You have EFI running on a board but U-Boot does not natively support it
32fully yet. You can boot into U-Boot from EFI and use that until U-Boot is
33fully ported
34
35- You need to use an EFI implementation (e.g. UEFI) because your vendor
36requires it in order to provide support
37
38- You plan to use coreboot to boot into U-Boot but coreboot support does
39not currently exist for your platform. In the meantime you can use U-Boot
40on EFI and then move to U-Boot on coreboot when ready
41
42- You use EFI but want to experiment with a simpler alternative like U-Boot
43
44
45Status
46------
47Only x86 is supported at present. If you are using EFI on another architecture
48you may want to reconsider. However, much of the code is generic so could be
49ported.
50
51U-Boot supports running as an EFI application for 32-bit EFI only. This is
52not very useful since only a serial port is provided. You can look around at
53memory and type 'help' but that is about it.
54
55More usefully, U-Boot supports building itself as a payload for either 32-bit
56or 64-bit EFI. U-Boot is packaged up and loaded in its entirety by EFI. Once
57started, U-Boot changes to 32-bit mode (currently) and takes over the
58machine. You can use devices, boot a kernel, etc.
59
60
61Build Instructions
62------------------
63First choose a board that has EFI support and obtain an EFI implementation
64for that board. It will be either 32-bit or 64-bit. Alternatively, you can
65opt for using QEMU [1] and the OVMF [2], as detailed below.
66
67To build U-Boot as an EFI application (32-bit EFI required), enable CONFIG_EFI
68and CONFIG_EFI_APP. The efi-x86 config (efi-x86_defconfig) is set up for this.
69Just build U-Boot as normal, e.g.
70
71   make efi-x86_defconfig
72   make
73
74To build U-Boot as an EFI payload (32-bit or 64-bit EFI can be used), adjust an
75existing config (like qemu-x86_defconfig) to enable CONFIG_EFI, CONFIG_EFI_STUB
76and either CONFIG_EFI_STUB_32BIT or CONFIG_EFI_STUB_64BIT. All of these are
77boolean Kconfig options. Then build U-Boot as normal, e.g.
78
79   make qemu-x86_defconfig
80   make
81
82You will end up with one of these files depending on what you build for:
83
84   u-boot-app.efi      - U-Boot EFI application
85   u-boot-payload.efi  - U-Boot EFI payload application
86
87
88Trying it out
89-------------
90QEMU is an emulator and it can emulate an x86 machine. Please make sure your
91QEMU version is 2.3.0 or above to test this. You can run the payload with
92something like this:
93
94   mkdir /tmp/efi
95   cp /path/to/u-boot*.efi /tmp/efi
96   qemu-system-x86_64 -bios bios.bin -hda fat:/tmp/efi/
97
98Add -nographic if you want to use the terminal for output. Once it starts
99type 'fs0:u-boot-payload.efi' to run the payload or 'fs0:u-boot-app.efi' to
100run the application. 'bios.bin' is the EFI 'BIOS'. Check [2] to obtain a
101prebuilt EFI BIOS for QEMU or you can build one from source as well.
102
103To try it on real hardware, put u-boot-app.efi on a suitable boot medium,
104such as a USB stick. Then you can type something like this to start it:
105
106   fs0:u-boot-payload.efi
107
108(or fs0:u-boot-app.efi for the application)
109
110This will start the payload, copy U-Boot into RAM and start U-Boot. Note
111that EFI does not support booting a 64-bit application from a 32-bit
112EFI (or vice versa). Also it will often fail to print an error message if
113you get this wrong.
114
115
116Inner workings
117==============
118Here follow a few implementation notes for those who want to fiddle with
119this and perhaps contribute patches.
120
121The application and payload approaches sound similar but are in fact
122implemented completely differently.
123
124EFI Application
125---------------
126For the application the whole of U-Boot is built as a shared library. The
127efi_main() function is in lib/efi/efi_app.c. It sets up some basic EFI
128functions with efi_init(), sets up U-Boot global_data, allocates memory for
129U-Boot's malloc(), etc. and enters the normal init sequence (board_init_f()
130and board_init_r()).
131
132Since U-Boot limits its memory access to the allocated regions very little
133special code is needed. The CONFIG_EFI_APP option controls a few things
134that need to change so 'git grep CONFIG_EFI_APP' may be instructive.
135The CONFIG_EFI option controls more general EFI adjustments.
136
137The only available driver is the serial driver. This calls back into EFI
138'boot services' to send and receive characters. Although it is implemented
139as a serial driver the console device is not necessarilly serial. If you
140boot EFI with video output then the 'serial' device will operate on your
141target devices's display instead and the device's USB keyboard will also
142work if connected. If you have both serial and video output, then both
143consoles will be active. Even though U-Boot does the same thing normally,
144These are features of EFI, not U-Boot.
145
146Very little code is involved in implementing the EFI application feature.
147U-Boot is highly portable. Most of the difficulty is in modifying the
148Makefile settings to pass the right build flags. In particular there is very
149little x86-specific code involved - you can find most of it in
150arch/x86/cpu. Porting to ARM (which can also use EFI if you are brave
151enough) should be straightforward.
152
153Use the 'reset' command to get back to EFI.
154
155EFI Payload
156-----------
157The payload approach is a different kettle of fish. It works by building
158U-Boot exactly as normal for your target board, then adding the entire
159image (including device tree) into a small EFI stub application responsible
160for booting it. The stub application is built as a normal EFI application
161except that it has a lot of data attached to it.
162
163The stub application is implemented in lib/efi/efi_stub.c. The efi_main()
164function is called by EFI. It is responsible for copying U-Boot from its
165original location into memory, disabling EFI boot services and starting
166U-Boot. U-Boot then starts as normal, relocates, starts all drivers, etc.
167
168The stub application is architecture-dependent. At present it has some
169x86-specific code and a comment at the top of efi_stub.c describes this.
170
171While the stub application does allocate some memory from EFI this is not
172used by U-Boot (the payload). In fact when U-Boot starts it has all of the
173memory available to it and can operate as it pleases (but see the next
174section).
175
176Tables
177------
178The payload can pass information to U-Boot in the form of EFI tables. At
179present this feature is used to pass the EFI memory map, an inordinately
180large list of memory regions. You can use the 'efi mem all' command to
181display this list. U-Boot uses the list to work out where to relocate
182itself.
183
184Although U-Boot can use any memory it likes, EFI marks some memory as used
185by 'run-time services', code that hangs around while U-Boot is running and
186is even present when Linux is running. This is common on x86 and provides
187a way for Linux to call back into the firmware to control things like CPU
188fan speed. U-Boot uses only 'conventional' memory, in EFI terminology. It
189will relocate itself to the top of the largest block of memory it can find
190below 4GB.
191
192Interrupts
193----------
194U-Boot drivers typically don't use interrupts. Since EFI enables interrupts
195it is possible that an interrupt will fire that U-Boot cannot handle. This
196seems to cause problems. For this reason the U-Boot payload runs with
197interrupts disabled at present.
198
19932/64-bit
200---------
201While the EFI application can in principle be built as either 32- or 64-bit,
202only 32-bit is currently supported. This means that the application can only
203be used with 32-bit EFI.
204
205The payload stub can be build as either 32- or 64-bits. Only a small amount
206of code is built this way (see the extra- line in lib/efi/Makefile).
207Everything else is built as a normal U-Boot, so is always 32-bit on x86 at
208present.
209
210Future work
211-----------
212This work could be extended in a number of ways:
213
214- Add a generic x86 EFI payload configuration. At present you need to modify
215an existing one, but mostly the low-level x86 code is disabled when booting
216on EFI anyway, so a generic 'EFI' board could be created with a suitable set
217of drivers enabled.
218
219- Add ARM support
220
221- Add 64-bit application support
222
223- Figure out how to solve the interrupt problem
224
225- Add more drivers to the application side (e.g. video, block devices, USB,
226environment access). This would mostly be an academic exercise as a strong
227use case is not readily apparent, but it might be fun.
228
229- Avoid turning off boot services in the stub. Instead allow U-Boot to make
230use of boot services in case it wants to. It is unclear what it might want
231though.
232
233Where is the code?
234------------------
235lib/efi
236	payload stub, application, support code. Mostly arch-neutral
237
238arch/x86/lib/efi
239	helper functions for the fake DRAM init, etc. These can be used by
240	any board that runs as a payload.
241
242arch/x86/cpu/efi
243	x86 support code for running as an EFI application
244
245board/efi/efi-x86/efi.c
246	x86 board code for running as an EFI application
247
248common/cmd_efi.c
249	the 'efi' command
250
251--
252Ben Stoltz, Simon Glass
253Google, Inc
254July 2015
255
256[1] http://www.qemu.org
257[2] http://www.tianocore.org/ovmf/
258