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