doc/uefi/uefi.rst

   1 .. SPDX-License-Identifier: GPL-2.0+
   2 .. Copyright (c) 2018 Heinrich Schuchardt
   3
   4 UEFI on U-Boot
   5 ==============
   6
   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.
  12
  13 Development target
  14 ------------------
  15
  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
  20 reference.
  21
  22 A full blown UEFI implementation would contradict the U-Boot design principle
  23 "keep it small".
  24
  25 Building U-Boot for UEFI
  26 ------------------------
  27
  28 The UEFI standard supports only little-endian systems. The UEFI support can be
  29 activated for ARM and x86 by specifying::
  30
  31     CONFIG_CMD_BOOTEFI=y
  32     CONFIG_EFI_LOADER=y
  33
  34 in the .config file.
  35
  36 Support for attaching virtual block devices, e.g. iSCSI drives connected by the
  37 loaded UEFI application [4], requires::
  38
  39     CONFIG_BLK=y
  40     CONFIG_PARTITIONS=y
  41
  42 Executing a UEFI binary
  43 ~~~~~~~~~~~~~~~~~~~~~~~
  44
  45 The bootefi command is used to start UEFI applications or to install UEFI
  46 drivers. It takes two parameters::
  47
  48     bootefi <image address> [fdt address]
  49
  50 * image address - the memory address of the UEFI binary
  51 * fdt address - the memory address of the flattened device tree
  52
  53 Below you find the output of an example session starting GRUB::
  54
  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}
  61
  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
  64 arguments.
  65
  66 Launching a UEFI binary from a FIT image
  67 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  68
  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::
  71
  72     CONFIG_BOOTM_EFI=y
  73
  74 A sample configuration is provided as file doc/uImage.FIT/uefi.its.
  75
  76 Below you find the output of an example session starting GRUB::
  77
  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
  91          Hash algo:    sha256
  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) ...
  96     Welcome to GRUB!
  97
  98 See doc/uImage.FIT/howto.txt for an introduction to FIT images.
  99
 100 Executing the boot manager
 101 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 102
 103 The UEFI specification foresees to define boot entries and boot sequence via UEFI
 104 variables. Booting according to these variables is possible via::
 105
 106     bootefi bootmgr [fdt address]
 107
 108 As of U-Boot v2018.03 UEFI variables are not persisted and cannot be set at
 109 runtime.
 110
 111 Executing the built in hello world application
 112 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 113
 114 A hello world UEFI application can be built with::
 115
 116     CONFIG_CMD_BOOTEFI_HELLO_COMPILE=y
 117
 118 It can be embedded into the U-Boot binary with::
 119
 120     CONFIG_CMD_BOOTEFI_HELLO=y
 121
 122 The bootefi command is used to start the embedded hello world application::
 123
 124     bootefi hello [fdt address]
 125
 126 Below you find the output of an example session::
 127
 128     => bootefi hello ${fdtcontroladdr}
 129     ## Starting EFI application at 01000000 ...
 130     WARNING: using memory device/image path, this may confuse some payloads!
 131     Hello, world!
 132     Running on UEFI 2.7
 133     Have SMBIOS table
 134     Have device tree
 135     Load options: root=/dev/sdb3 init=/sbin/init rootwait ro
 136     ## Application terminated, r = 0
 137
 138 The environment variable fdtcontroladdr points to U-Boot's internal device tree
 139 (if available).
 140
 141 Executing the built-in self-test
 142 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 143
 144 An UEFI self-test suite can be embedded in U-Boot by building with::
 145
 146     CONFIG_CMD_BOOTEFI_SELFTEST=y
 147
 148 For testing the UEFI implementation the bootefi command can be used to start the
 149 self-test::
 150
 151     bootefi selftest [fdt address]
 152
 153 The environment variable 'efi_selftest' can be used to select a single test. If
 154 it is not provided all tests are executed except those marked as 'on request'.
 155 If the environment variable is set to 'list' a list of all tests is shown.
 156
 157 Below you can find the output of an example session::
 158
 159     => setenv efi_selftest simple network protocol
 160     => bootefi selftest
 161     Testing EFI API implementation
 162     Selected test: 'simple network protocol'
 163     Setting up 'simple network protocol'
 164     Setting up 'simple network protocol' succeeded
 165     Executing 'simple network protocol'
 166     DHCP Discover
 167     DHCP reply received from 192.168.76.2 (52:55:c0:a8:4c:02)
 168       as broadcast message.
 169     Executing 'simple network protocol' succeeded
 170     Tearing down 'simple network protocol'
 171     Tearing down 'simple network protocol' succeeded
 172     Boot services terminated
 173     Summary: 0 failures
 174     Preparing for reset. Press any key.
 175
 176 The UEFI life cycle
 177 -------------------
 178
 179 After the U-Boot platform has been initialized the UEFI API provides two kinds
 180 of services:
 181
 182 * boot services
 183 * runtime services
 184
 185 The API can be extended by loading UEFI drivers which come in two variants:
 186
 187 * boot drivers
 188 * runtime drivers
 189
 190 UEFI drivers are installed with U-Boot's bootefi command. With the same command
 191 UEFI applications can be executed.
 192
 193 Loaded images of UEFI drivers stay in memory after returning to U-Boot while
 194 loaded images of applications are removed from memory.
 195
 196 An UEFI application (e.g. an operating system) that wants to take full control
 197 of the system calls ExitBootServices. After a UEFI application calls
 198 ExitBootServices
 199
 200 * boot services are not available anymore
 201 * timer events are stopped
 202 * the memory used by U-Boot except for runtime services is released
 203 * the memory used by boot time drivers is released
 204
 205 So this is a point of no return. Afterwards the UEFI application can only return
 206 to U-Boot by rebooting.
 207
 208 The UEFI object model
 209 ---------------------
 210
 211 UEFI offers a flexible and expandable object model. The objects in the UEFI API
 212 are devices, drivers, and loaded images. These objects are referenced by
 213 handles.
 214
 215 The interfaces implemented by the objects are referred to as protocols. These
 216 are identified by GUIDs. They can be installed and uninstalled by calling the
 217 appropriate boot services.
 218
 219 Handles are created by the InstallProtocolInterface or the
 220 InstallMultipleProtocolinterfaces service if NULL is passed as handle.
 221
 222 Handles are deleted when the last protocol has been removed with the
 223 UninstallProtocolInterface or the UninstallMultipleProtocolInterfaces service.
 224
 225 Devices offer the EFI_DEVICE_PATH_PROTOCOL. A device path is the concatenation
 226 of device nodes. By their device paths all devices of a system are arranged in a
 227 tree.
 228
 229 Drivers offer the EFI_DRIVER_BINDING_PROTOCOL. This protocol is used to connect
 230 a driver to devices (which are referenced as controllers in this context).
 231
 232 Loaded images offer the EFI_LOADED_IMAGE_PROTOCOL. This protocol provides meta
 233 information about the image and a pointer to the unload callback function.
 234
 235 The UEFI events
 236 ---------------
 237
 238 In the UEFI terminology an event is a data object referencing a notification
 239 function which is queued for calling when the event is signaled. The following
 240 types of events exist:
 241
 242 * periodic and single shot timer events
 243 * exit boot services events, triggered by calling the ExitBootServices() service
 244 * virtual address change events
 245 * memory map change events
 246 * read to boot events
 247 * reset system events
 248 * system table events
 249 * events that are only triggered programmatically
 250
 251 Events can be created with the CreateEvent service and deleted with CloseEvent
 252 service.
 253
 254 Events can be assigned to an event group. If any of the events in a group is
 255 signaled, all other events in the group are also set to the signaled state.
 256
 257 The UEFI driver model
 258 ---------------------
 259
 260 A driver is specific for a single protocol installed on a device. To install a
 261 driver on a device the ConnectController service is called. In this context
 262 controller refers to the device for which the driver is installed.
 263
 264 The relevant drivers are identified using the EFI_DRIVER_BINDING_PROTOCOL. This
 265 protocol has has three functions:
 266
 267 * supported - determines if the driver is compatible with the device
 268 * start - installs the driver by opening the relevant protocol with
 269   attribute EFI_OPEN_PROTOCOL_BY_DRIVER
 270 * stop - uninstalls the driver
 271
 272 The driver may create child controllers (child devices). E.g. a driver for block
 273 IO devices will create the device handles for the partitions. The child
 274 controllers  will open the supported protocol with the attribute
 275 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
 276
 277 A driver can be detached from a device using the DisconnectController service.
 278
 279 U-Boot devices mapped as UEFI devices
 280 -------------------------------------
 281
 282 Some of the U-Boot devices are mapped as UEFI devices
 283
 284 * block IO devices
 285 * console
 286 * graphical output
 287 * network adapter
 288
 289 As of U-Boot 2018.03 the logic for doing this is hard coded.
 290
 291 The development target is to integrate the setup of these UEFI devices with the
 292 U-Boot driver model [5]. So when a U-Boot device is discovered a handle should
 293 be created and the device path protocol and the relevant IO protocol should be
 294 installed. The UEFI driver then would be attached by calling ConnectController.
 295 When a U-Boot device is removed DisconnectController should be called.
 296
 297 UEFI devices mapped as U-Boot devices
 298 -------------------------------------
 299
 300 UEFI drivers binaries and applications may create new (virtual) devices, install
 301 a protocol and call the ConnectController service. Now the matching UEFI driver
 302 is determined by iterating over the implementations of the
 303 EFI_DRIVER_BINDING_PROTOCOL.
 304
 305 It is the task of the UEFI driver to create a corresponding U-Boot device and to
 306 proxy calls for this U-Boot device to the controller.
 307
 308 In U-Boot 2018.03 this has only been implemented for block IO devices.
 309
 310 UEFI uclass
 311 ~~~~~~~~~~~
 312
 313 An UEFI uclass driver (lib/efi_driver/efi_uclass.c) has been created that
 314 takes care of initializing the UEFI drivers and providing the
 315 EFI_DRIVER_BINDING_PROTOCOL implementation for the UEFI drivers.
 316
 317 A linker created list is used to keep track of the UEFI drivers. To create an
 318 entry in the list the UEFI driver uses the U_BOOT_DRIVER macro specifying
 319 UCLASS_EFI as the ID of its uclass, e.g::
 320
 321     /* Identify as UEFI driver */
 322     U_BOOT_DRIVER(efi_block) = {
 323         .name  = "EFI block driver",
 324         .id    = UCLASS_EFI,
 325         .ops   = &driver_ops,
 326     };
 327
 328 The available operations are defined via the structure struct efi_driver_ops::
 329
 330     struct efi_driver_ops {
 331         const efi_guid_t *protocol;
 332         const efi_guid_t *child_protocol;
 333         int (*bind)(efi_handle_t handle, void *interface);
 334     };
 335
 336 When the supported() function of the EFI_DRIVER_BINDING_PROTOCOL is called the
 337 uclass checks if the protocol GUID matches the protocol GUID of the UEFI driver.
 338 In the start() function the bind() function of the UEFI driver is called after
 339 checking the GUID.
 340 The stop() function of the EFI_DRIVER_BINDING_PROTOCOL disconnects the child
 341 controllers created by the UEFI driver and the UEFI driver. (In U-Boot v2013.03
 342 this is not yet completely implemented.)
 343
 344 UEFI block IO driver
 345 ~~~~~~~~~~~~~~~~~~~~
 346
 347 The UEFI block IO driver supports devices exposing the EFI_BLOCK_IO_PROTOCOL.
 348
 349 When connected it creates a new U-Boot block IO device with interface type
 350 IF_TYPE_EFI, adds child controllers mapping the partitions, and installs the
 351 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL on these. This can be used together with the
 352 software iPXE to boot from iSCSI network drives [4].
 353
 354 This driver is only available if U-Boot is configured with::
 355
 356     CONFIG_BLK=y
 357     CONFIG_PARTITIONS=y
 358
 359 Miscellaneous
 360 -------------
 361
 362 Load file 2 protocol
 363 ~~~~~~~~~~~~~~~~~~~~
 364
 365 The load file 2 protocol can be used by the Linux kernel to load the initial
 366 RAM disk. U-Boot can be configured to provide an implementation with::
 367
 368     EFI_LOAD_FILE2_INITRD=y
 369     EFI_INITRD_FILESPEC=interface dev:part path_to_initrd
 370
 371 Links
 372 -----
 373
 374 * [1] http://uefi.org/specifications - UEFI specifications
 375 * [2] https://github.com/ARM-software/ebbr/releases/download/v1.0/ebbr-v1.0.pdf -
 376   Embedded Base Boot Requirements (EBBR) Specification - Release v1.0
 377 * [3] https://developer.arm.com/docs/den0044/latest/server-base-boot-requirements-system-software-on-arm-platforms-version-11 -
 378   Server Base Boot Requirements System Software on ARM Platforms - Version 1.1
 379 * [4] :doc:`iscsi`
 380 * [5] :doc:`../driver-model/index`