1 .. SPDX-License-Identifier: GPL-2.0+
2 .. Copyright (c) 2018 Heinrich Schuchardt
7 The Unified Extensible Firmware Interface Specification (UEFI) [1] has become
8 the default for booting on AArch64 and x86 systems. It provides a stable API for
9 the interaction of drivers and applications with the firmware. The API comprises
10 access to block storage, network, and console to name a few. The Linux kernel
11 and boot loaders like GRUB or the FreeBSD loader can be executed.
16 The implementation of UEFI in U-Boot strives to reach the requirements described
17 in the "Embedded Base Boot Requirements (EBBR) Specification - Release v1.0"
18 [2]. The "Server Base Boot Requirements System Software on ARM Platforms" [3]
19 describes a superset of the EBBR specification and may be used as further
22 A full blown UEFI implementation would contradict the U-Boot design principle
25 Building U-Boot for UEFI
26 ------------------------
28 The UEFI standard supports only little-endian systems. The UEFI support can be
29 activated for ARM and x86 by specifying::
36 Support for attaching virtual block devices, e.g. iSCSI drives connected by the
37 loaded UEFI application [4], requires::
42 Executing a UEFI binary
43 ~~~~~~~~~~~~~~~~~~~~~~~
45 The bootefi command is used to start UEFI applications or to install UEFI
46 drivers. It takes two parameters::
48 bootefi <image address> [fdt address]
50 * image address - the memory address of the UEFI binary
51 * fdt address - the memory address of the flattened device tree
53 Below you find the output of an example session starting GRUB::
55 => load mmc 0:2 ${fdt_addr_r} boot/dtb
56 29830 bytes read in 14 ms (2 MiB/s)
57 => load mmc 0:1 ${kernel_addr_r} efi/debian/grubaa64.efi
58 reading efi/debian/grubaa64.efi
59 120832 bytes read in 7 ms (16.5 MiB/s)
60 => bootefi ${kernel_addr_r} ${fdt_addr_r}
62 The environment variable 'bootargs' is passed as load options in the UEFI system
63 table. The Linux kernel EFI stub uses the load options as command line
66 Launching a UEFI binary from a FIT image
67 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
69 A signed FIT image can be used to securely boot a UEFI image via the
70 bootm command. This feature is available if U-Boot is configured with::
74 A sample configuration is provided as file doc/uImage.FIT/uefi.its.
76 Below you find the output of an example session starting GRUB::
78 => load mmc 0:1 ${kernel_addr_r} image.fit
79 4620426 bytes read in 83 ms (53.1 MiB/s)
80 => bootm ${kernel_addr_r}#config-grub-nofdt
81 ## Loading kernel from FIT Image at 40400000 ...
82 Using 'config-grub-nofdt' configuration
83 Verifying Hash Integrity ... sha256,rsa2048:dev+ OK
84 Trying 'efi-grub' kernel subimage
85 Description: GRUB EFI Firmware
86 Created: 2019-11-20 8:18:16 UTC
87 Type: Kernel Image (no loading done)
88 Compression: uncompressed
89 Data Start: 0x404000d0
90 Data Size: 450560 Bytes = 440 KiB
92 Hash value: 4dbee00021112df618f58b3f7cf5e1595533d543094064b9ce991e8b054a9eec
93 Verifying Hash Integrity ... sha256+ OK
94 XIP Kernel Image (no loading done)
95 ## Transferring control to EFI (at address 404000d0) ...
98 See doc/uImage.FIT/howto.txt for an introduction to FIT images.
100 Configuring UEFI secure boot
101 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
103 UEFI specification[1] defines a secure way of executing UEFI images
104 by verifying a signature (or message digest) of image with certificates.
105 This feature on U-Boot is enabled with::
107 CONFIG_UEFI_SECURE_BOOT=y
109 To make the boot sequence safe, you need to establish a chain of trust;
110 In UEFI secure boot, you can make it with the UEFI variables, "PK"
111 (Platform Key), "KEK" (Key Exchange Keys), "db" (white list database)
112 and "dbx" (black list database).
114 There are many online documents that describe what UEFI secure boot is
115 and how it works. Please consult some of them for details.
117 Here is a simple example that you can follow for your initial attempt
118 (Please note that the actual steps would absolutely depend on your system
121 1. Install utility commands on your host
126 2. Create signing keys and key database files on your host
129 $ openssl req -x509 -sha256 -newkey rsa:2048 -subj /CN=TEST_PK/ \
130 -keyout PK.key -out PK.crt -nodes -days 365
131 $ cert-to-efi-sig-list -g 11111111-2222-3333-4444-123456789abc \
133 $ sign-efi-sig-list -c PK.crt -k PK.key PK PK.esl PK.auth
137 $ openssl req -x509 -sha256 -newkey rsa:2048 -subj /CN=TEST_KEK/ \
138 -keyout KEK.key -out KEK.crt -nodes -days 365
139 $ cert-to-efi-sig-list -g 11111111-2222-3333-4444-123456789abc \
141 $ sign-efi-sig-list -c PK.crt -k PK.key KEK KEK.esl KEK.auth
145 $ openssl req -x509 -sha256 -newkey rsa:2048 -subj /CN=TEST_db/ \
146 -keyout db.key -out db.crt -nodes -days 365
147 $ cert-to-efi-sig-list -g 11111111-2222-3333-4444-123456789abc \
149 $ sign-efi-sig-list -c KEK.crt -k KEK.key db db.esl db.auth
151 Copy \*.auth to media, say mmc, that is accessible from U-Boot.
153 3. Sign an image with one key in "db" on your host::
155 $ sbsign --key db.key --cert db.crt helloworld.efi
157 4. Install keys on your board::
159 ==> fatload mmc 0:1 <tmpaddr> PK.auth
160 ==> setenv -e -nv -bs -rt -at -i <tmpaddr>,$filesize PK
161 ==> fatload mmc 0:1 <tmpaddr> KEK.auth
162 ==> setenv -e -nv -bs -rt -at -i <tmpaddr>,$filesize KEK
163 ==> fatload mmc 0:1 <tmpaddr> db.auth
164 ==> setenv -e -nv -bs -rt -at -i <tmpaddr>,$filesize db
166 5. Set up boot parameters on your board::
168 ==> efidebug boot add 1 HELLO mmc 0:1 /helloworld.efi.signed ""
170 Then your board runs that image from Boot manager (See below).
171 You can also try this sequence by running Pytest, test_efi_secboot,
174 $ cd <U-Boot source directory>
175 $ pytest.py test/py/tests/test_efi_secboot/test_signed.py --bd sandbox
177 Executing the boot manager
178 ~~~~~~~~~~~~~~~~~~~~~~~~~~
180 The UEFI specification foresees to define boot entries and boot sequence via UEFI
181 variables. Booting according to these variables is possible via::
183 bootefi bootmgr [fdt address]
185 As of U-Boot v2018.03 UEFI variables are not persisted and cannot be set at
188 Executing the built in hello world application
189 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
191 A hello world UEFI application can be built with::
193 CONFIG_CMD_BOOTEFI_HELLO_COMPILE=y
195 It can be embedded into the U-Boot binary with::
197 CONFIG_CMD_BOOTEFI_HELLO=y
199 The bootefi command is used to start the embedded hello world application::
201 bootefi hello [fdt address]
203 Below you find the output of an example session::
205 => bootefi hello ${fdtcontroladdr}
206 ## Starting EFI application at 01000000 ...
207 WARNING: using memory device/image path, this may confuse some payloads!
212 Load options: root=/dev/sdb3 init=/sbin/init rootwait ro
213 ## Application terminated, r = 0
215 The environment variable fdtcontroladdr points to U-Boot's internal device tree
218 Executing the built-in self-test
219 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
221 An UEFI self-test suite can be embedded in U-Boot by building with::
223 CONFIG_CMD_BOOTEFI_SELFTEST=y
225 For testing the UEFI implementation the bootefi command can be used to start the
228 bootefi selftest [fdt address]
230 The environment variable 'efi_selftest' can be used to select a single test. If
231 it is not provided all tests are executed except those marked as 'on request'.
232 If the environment variable is set to 'list' a list of all tests is shown.
234 Below you can find the output of an example session::
236 => setenv efi_selftest simple network protocol
238 Testing EFI API implementation
239 Selected test: 'simple network protocol'
240 Setting up 'simple network protocol'
241 Setting up 'simple network protocol' succeeded
242 Executing 'simple network protocol'
244 DHCP reply received from 192.168.76.2 (52:55:c0:a8:4c:02)
245 as broadcast message.
246 Executing 'simple network protocol' succeeded
247 Tearing down 'simple network protocol'
248 Tearing down 'simple network protocol' succeeded
249 Boot services terminated
251 Preparing for reset. Press any key.
256 After the U-Boot platform has been initialized the UEFI API provides two kinds
262 The API can be extended by loading UEFI drivers which come in two variants:
267 UEFI drivers are installed with U-Boot's bootefi command. With the same command
268 UEFI applications can be executed.
270 Loaded images of UEFI drivers stay in memory after returning to U-Boot while
271 loaded images of applications are removed from memory.
273 An UEFI application (e.g. an operating system) that wants to take full control
274 of the system calls ExitBootServices. After a UEFI application calls
277 * boot services are not available anymore
278 * timer events are stopped
279 * the memory used by U-Boot except for runtime services is released
280 * the memory used by boot time drivers is released
282 So this is a point of no return. Afterwards the UEFI application can only return
283 to U-Boot by rebooting.
285 The UEFI object model
286 ---------------------
288 UEFI offers a flexible and expandable object model. The objects in the UEFI API
289 are devices, drivers, and loaded images. These objects are referenced by
292 The interfaces implemented by the objects are referred to as protocols. These
293 are identified by GUIDs. They can be installed and uninstalled by calling the
294 appropriate boot services.
296 Handles are created by the InstallProtocolInterface or the
297 InstallMultipleProtocolinterfaces service if NULL is passed as handle.
299 Handles are deleted when the last protocol has been removed with the
300 UninstallProtocolInterface or the UninstallMultipleProtocolInterfaces service.
302 Devices offer the EFI_DEVICE_PATH_PROTOCOL. A device path is the concatenation
303 of device nodes. By their device paths all devices of a system are arranged in a
306 Drivers offer the EFI_DRIVER_BINDING_PROTOCOL. This protocol is used to connect
307 a driver to devices (which are referenced as controllers in this context).
309 Loaded images offer the EFI_LOADED_IMAGE_PROTOCOL. This protocol provides meta
310 information about the image and a pointer to the unload callback function.
315 In the UEFI terminology an event is a data object referencing a notification
316 function which is queued for calling when the event is signaled. The following
317 types of events exist:
319 * periodic and single shot timer events
320 * exit boot services events, triggered by calling the ExitBootServices() service
321 * virtual address change events
322 * memory map change events
323 * read to boot events
324 * reset system events
325 * system table events
326 * events that are only triggered programmatically
328 Events can be created with the CreateEvent service and deleted with CloseEvent
331 Events can be assigned to an event group. If any of the events in a group is
332 signaled, all other events in the group are also set to the signaled state.
334 The UEFI driver model
335 ---------------------
337 A driver is specific for a single protocol installed on a device. To install a
338 driver on a device the ConnectController service is called. In this context
339 controller refers to the device for which the driver is installed.
341 The relevant drivers are identified using the EFI_DRIVER_BINDING_PROTOCOL. This
342 protocol has has three functions:
344 * supported - determines if the driver is compatible with the device
345 * start - installs the driver by opening the relevant protocol with
346 attribute EFI_OPEN_PROTOCOL_BY_DRIVER
347 * stop - uninstalls the driver
349 The driver may create child controllers (child devices). E.g. a driver for block
350 IO devices will create the device handles for the partitions. The child
351 controllers will open the supported protocol with the attribute
352 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
354 A driver can be detached from a device using the DisconnectController service.
356 U-Boot devices mapped as UEFI devices
357 -------------------------------------
359 Some of the U-Boot devices are mapped as UEFI devices
366 As of U-Boot 2018.03 the logic for doing this is hard coded.
368 The development target is to integrate the setup of these UEFI devices with the
369 U-Boot driver model [5]. So when a U-Boot device is discovered a handle should
370 be created and the device path protocol and the relevant IO protocol should be
371 installed. The UEFI driver then would be attached by calling ConnectController.
372 When a U-Boot device is removed DisconnectController should be called.
374 UEFI devices mapped as U-Boot devices
375 -------------------------------------
377 UEFI drivers binaries and applications may create new (virtual) devices, install
378 a protocol and call the ConnectController service. Now the matching UEFI driver
379 is determined by iterating over the implementations of the
380 EFI_DRIVER_BINDING_PROTOCOL.
382 It is the task of the UEFI driver to create a corresponding U-Boot device and to
383 proxy calls for this U-Boot device to the controller.
385 In U-Boot 2018.03 this has only been implemented for block IO devices.
390 An UEFI uclass driver (lib/efi_driver/efi_uclass.c) has been created that
391 takes care of initializing the UEFI drivers and providing the
392 EFI_DRIVER_BINDING_PROTOCOL implementation for the UEFI drivers.
394 A linker created list is used to keep track of the UEFI drivers. To create an
395 entry in the list the UEFI driver uses the U_BOOT_DRIVER macro specifying
396 UCLASS_EFI as the ID of its uclass, e.g::
398 /* Identify as UEFI driver */
399 U_BOOT_DRIVER(efi_block) = {
400 .name = "EFI block driver",
405 The available operations are defined via the structure struct efi_driver_ops::
407 struct efi_driver_ops {
408 const efi_guid_t *protocol;
409 const efi_guid_t *child_protocol;
410 int (*bind)(efi_handle_t handle, void *interface);
413 When the supported() function of the EFI_DRIVER_BINDING_PROTOCOL is called the
414 uclass checks if the protocol GUID matches the protocol GUID of the UEFI driver.
415 In the start() function the bind() function of the UEFI driver is called after
417 The stop() function of the EFI_DRIVER_BINDING_PROTOCOL disconnects the child
418 controllers created by the UEFI driver and the UEFI driver. (In U-Boot v2013.03
419 this is not yet completely implemented.)
424 The UEFI block IO driver supports devices exposing the EFI_BLOCK_IO_PROTOCOL.
426 When connected it creates a new U-Boot block IO device with interface type
427 IF_TYPE_EFI, adds child controllers mapping the partitions, and installs the
428 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL on these. This can be used together with the
429 software iPXE to boot from iSCSI network drives [4].
431 This driver is only available if U-Boot is configured with::
442 The load file 2 protocol can be used by the Linux kernel to load the initial
443 RAM disk. U-Boot can be configured to provide an implementation with::
445 EFI_LOAD_FILE2_INITRD=y
446 EFI_INITRD_FILESPEC=interface dev:part path_to_initrd
451 * [1] http://uefi.org/specifications - UEFI specifications
452 * [2] https://github.com/ARM-software/ebbr/releases/download/v1.0/ebbr-v1.0.pdf -
453 Embedded Base Boot Requirements (EBBR) Specification - Release v1.0
454 * [3] https://developer.arm.com/docs/den0044/latest/server-base-boot-requirements-system-software-on-arm-platforms-version-11 -
455 Server Base Boot Requirements System Software on ARM Platforms - Version 1.1
457 * [5] :doc:`../driver-model/index`