doc/develop/uefi/u-boot_on_efi.rst

   1 .. SPDX-License-Identifier: GPL-2.0+
   2 .. Copyright (C) 2015 Google, Inc
   3
   4 U-Boot on EFI
   5 =============
   6 This document provides information about U-Boot running on top of EFI, either
   7 as an application or just as a means of getting U-Boot onto a new platform.
   8
   9
  10 Motivation
  11 ----------
  12 Running U-Boot on EFI is useful in several situations:
  13
  14 - You have EFI running on a board but U-Boot does not natively support it
  15   fully yet. You can boot into U-Boot from EFI and use that until U-Boot is
  16   fully ported
  17
  18 - You need to use an EFI implementation (e.g. UEFI) because your vendor
  19   requires it in order to provide support
  20
  21 - You plan to use coreboot to boot into U-Boot but coreboot support does
  22   not currently exist for your platform. In the meantime you can use U-Boot
  23   on EFI and then move to U-Boot on coreboot when ready
  24
  25 - You use EFI but want to experiment with a simpler alternative like U-Boot
  26
  27
  28 Status
  29 ------
  30 Only x86 is supported at present. If you are using EFI on another architecture
  31 you may want to reconsider. However, much of the code is generic so could be
  32 ported.
  33
  34 U-Boot supports running as an EFI application for 32-bit EFI only. This is
  35 not very useful since only a serial port is provided. You can look around at
  36 memory and type 'help' but that is about it.
  37
  38 More usefully, U-Boot supports building itself as a payload for either 32-bit
  39 or 64-bit EFI. U-Boot is packaged up and loaded in its entirety by EFI. Once
  40 started, U-Boot changes to 32-bit mode (currently) and takes over the
  41 machine. You can use devices, boot a kernel, etc.
  42
  43
  44 Build Instructions
  45 ------------------
  46 First choose a board that has EFI support and obtain an EFI implementation
  47 for that board. It will be either 32-bit or 64-bit. Alternatively, you can
  48 opt for using QEMU [1] and the OVMF [2], as detailed below.
  49
  50 To build U-Boot as an EFI application (32-bit EFI required), enable CONFIG_EFI
  51 and CONFIG_EFI_APP. The efi-x86_app config (efi-x86_app32_defconfig) is set up
  52 for this. Just build U-Boot as normal, e.g.::
  53
  54    make efi-x86_app32_defconfig
  55    make
  56
  57 To build U-Boot as an EFI payload (32-bit or 64-bit EFI can be used), enable
  58 CONFIG_EFI, CONFIG_EFI_STUB, and select either CONFIG_EFI_STUB_32BIT or
  59 CONFIG_EFI_STUB_64BIT. The efi-x86_payload configs (efi-x86_payload32_defconfig
  60 and efi-x86_payload32_defconfig) are set up for this. Then build U-Boot as
  61 normal, e.g.::
  62
  63    make efi-x86_payload32_defconfig (or efi-x86_payload64_defconfig)
  64    make
  65
  66 You will end up with one of these files depending on what you build for:
  67
  68 * u-boot-app.efi - U-Boot EFI application
  69 * u-boot-payload.efi  - U-Boot EFI payload application
  70
  71
  72 Trying it out
  73 -------------
  74 QEMU is an emulator and it can emulate an x86 machine. Please make sure your
  75 QEMU version is 6.0.0 or above to test this. You can run the payload with
  76 something like this::
  77
  78    mkdir /tmp/efi
  79    cp /path/to/u-boot*.efi /tmp/efi
  80    qemu-system-x86_64 -pflash edk2-x86_64-code.fd -hda fat:rw:/tmp/efi/
  81
  82 Add -nographic if you want to use the terminal for output. Once it starts
  83 type 'fs0:u-boot-payload.efi' to run the payload or 'fs0:u-boot-app.efi' to
  84 run the application. 'edk2-x86_64-code.fd' is the EFI 'BIOS'. QEMU already
  85 ships both 32-bit and 64-bit EFI BIOS images. For 32-bit EFI 'BIOS' image,
  86 use 'edk2-i386-code.fd'.
  87
  88
  89 To try it on real hardware, put u-boot-app.efi on a suitable boot medium,
  90 such as a USB stick. Then you can type something like this to start it::
  91
  92    fs0:u-boot-payload.efi
  93
  94 (or fs0:u-boot-app.efi for the application)
  95
  96 This will start the payload, copy U-Boot into RAM and start U-Boot. Note
  97 that EFI does not support booting a 64-bit application from a 32-bit
  98 EFI (or vice versa). Also it will often fail to print an error message if
  99 you get this wrong.
 100
 101 You may find the script `scripts/build-efi.sh` helpful for building and testing
 102 U-Boot on UEFI on QEMU. It also includes links to UEFI binaries dating from
 103 2021.
 104
 105 See `Example run`_ for an example run.
 106
 107 Inner workings
 108 --------------
 109 Here follow a few implementation notes for those who want to fiddle with
 110 this and perhaps contribute patches.
 111
 112 The application and payload approaches sound similar but are in fact
 113 implemented completely differently.
 114
 115 EFI Application
 116 ~~~~~~~~~~~~~~~
 117 For the application the whole of U-Boot is built as a shared library. The
 118 efi_main() function is in lib/efi/efi_app.c. It sets up some basic EFI
 119 functions with efi_init(), sets up U-Boot global_data, allocates memory for
 120 U-Boot's malloc(), etc. and enters the normal init sequence (board_init_f()
 121 and board_init_r()).
 122
 123 Since U-Boot limits its memory access to the allocated regions very little
 124 special code is needed. The CONFIG_EFI_APP option controls a few things
 125 that need to change so 'git grep CONFIG_EFI_APP' may be instructive.
 126 The CONFIG_EFI option controls more general EFI adjustments.
 127
 128 The only available driver is the serial driver. This calls back into EFI
 129 'boot services' to send and receive characters. Although it is implemented
 130 as a serial driver the console device is not necessarilly serial. If you
 131 boot EFI with video output then the 'serial' device will operate on your
 132 target devices's display instead and the device's USB keyboard will also
 133 work if connected. If you have both serial and video output, then both
 134 consoles will be active. Even though U-Boot does the same thing normally,
 135 These are features of EFI, not U-Boot.
 136
 137 Very little code is involved in implementing the EFI application feature.
 138 U-Boot is highly portable. Most of the difficulty is in modifying the
 139 Makefile settings to pass the right build flags. In particular there is very
 140 little x86-specific code involved - you can find most of it in
 141 arch/x86/cpu. Porting to ARM (which can also use EFI if you are brave
 142 enough) should be straightforward.
 143
 144 Use the 'reset' command to get back to EFI.
 145
 146 EFI Payload
 147 ~~~~~~~~~~~
 148 The payload approach is a different kettle of fish. It works by building
 149 U-Boot exactly as normal for your target board, then adding the entire
 150 image (including device tree) into a small EFI stub application responsible
 151 for booting it. The stub application is built as a normal EFI application
 152 except that it has a lot of data attached to it.
 153
 154 The stub application is implemented in lib/efi/efi_stub.c. The efi_main()
 155 function is called by EFI. It is responsible for copying U-Boot from its
 156 original location into memory, disabling EFI boot services and starting
 157 U-Boot. U-Boot then starts as normal, relocates, starts all drivers, etc.
 158
 159 The stub application is architecture-dependent. At present it has some
 160 x86-specific code and a comment at the top of efi_stub.c describes this.
 161
 162 While the stub application does allocate some memory from EFI this is not
 163 used by U-Boot (the payload). In fact when U-Boot starts it has all of the
 164 memory available to it and can operate as it pleases (but see the next
 165 section).
 166
 167 Tables
 168 ~~~~~~
 169 The payload can pass information to U-Boot in the form of EFI tables. At
 170 present this feature is used to pass the EFI memory map, an inordinately
 171 large list of memory regions. You can use the 'efi mem all' command to
 172 display this list. U-Boot uses the list to work out where to relocate
 173 itself.
 174
 175 Although U-Boot can use any memory it likes, EFI marks some memory as used
 176 by 'run-time services', code that hangs around while U-Boot is running and
 177 is even present when Linux is running. This is common on x86 and provides
 178 a way for Linux to call back into the firmware to control things like CPU
 179 fan speed. U-Boot uses only 'conventional' memory, in EFI terminology. It
 180 will relocate itself to the top of the largest block of memory it can find
 181 below 4GB.
 182
 183 Interrupts
 184 ~~~~~~~~~~
 185 U-Boot drivers typically don't use interrupts. Since EFI enables interrupts
 186 it is possible that an interrupt will fire that U-Boot cannot handle. This
 187 seems to cause problems. For this reason the U-Boot payload runs with
 188 interrupts disabled at present.
 189
 190 32/64-bit
 191 ~~~~~~~~~
 192 While the EFI application can in principle be built as either 32- or 64-bit,
 193 only 32-bit is currently supported. This means that the application can only
 194 be used with 32-bit EFI.
 195
 196 The payload stub can be build as either 32- or 64-bits. Only a small amount
 197 of code is built this way (see the extra- line in lib/efi/Makefile).
 198 Everything else is built as a normal U-Boot, so is always 32-bit on x86 at
 199 present.
 200
 201 Example run
 202 -----------
 203
 204 This shows running with serial enabled (see `include/configs/efi-x86_app.h`)::
 205
 206    $ scripts/build-efi.sh -wsPr
 207    Packaging efi-x86_app32
 208    Running qemu-system-i386
 209
 210    BdsDxe: failed to load Boot0001 "UEFI QEMU HARDDISK QM00005 " from PciRoot(0x0)/Pci(0x3,0x0)/Sata(0x0,0xFFFF,0x0): Not Found
 211    BdsDxe: loading Boot0002 "EFI Internal Shell" from Fv(7CB8BDC9-F8EB-4F34-AAEA-3EE4AF6516A1)/FvFile(7C04A583-9E3E-4F1C-AD65-E05268D0B4D1)
 212    BdsDxe: starting Boot0002 "EFI Internal Shell" from Fv(7CB8BDC9-F8EB-4F34-AAEA-3EE4AF6516A1)/FvFile(7C04A583-9E3E-4F1C-AD65-E05268D0B4D1)
 213
 214    UEFI Interactive Shell v2.2
 215    EDK II
 216    UEFI v2.70 (EDK II, 0x00010000)
 217    Mapping table
 218          FS0: Alias(s):HD0a65535a1:;BLK1:
 219              PciRoot(0x0)/Pci(0x3,0x0)/Sata(0x0,0xFFFF,0x0)/HD(1,GPT,0FFD5E61-3B0C-4326-8049-BDCDC910AF72,0x800,0xB000)
 220         BLK0: Alias(s):
 221              PciRoot(0x0)/Pci(0x3,0x0)/Sata(0x0,0xFFFF,0x0)
 222
 223    Press ESC in 5 seconds to skip startup.nsh or any other key to continue.
 224    Shell> fs0:u-boot-app.efi
 225    U-Boot EFI App (using allocated RAM address 47d4000) key=8d4, image=06a6f610
 226    starting
 227
 228
 229    U-Boot 2022.01-rc4 (Sep 19 2021 - 14:03:20 -0600)
 230
 231    CPU: x86, vendor Intel, device 663h
 232    DRAM:  32 MiB
 233     0: efi_media_0  PciRoot(0x0)/Pci(0x3,0x0)/Sata(0x0,0xFFFF,0x0)
 234     1: <partition>  PciRoot(0x0)/Pci(0x3,0x0)/Sata(0x0,0xFFFF,0x0)/HD(1,GPT,0FFD5E61-3B0C-4326-8049-BDCDC910AF72,0x800,0xB000)
 235    Loading Environment from nowhere... OK
 236    Model: EFI x86 Application
 237    Hit any key to stop autoboot:  0
 238
 239    Partition Map for EFI device 0  --   Partition Type: EFI
 240
 241    Part    Start LBA       End LBA            Name
 242            Attributes
 243            Type GUID
 244            Partition GUID
 245      1     0x00000800      0x0000b7ff      "boot"
 246            attrs:  0x0000000000000000
 247            type:   ebd0a0a2-b9e5-4433-87c0-68b6b72699c7
 248            guid:   0ffd5e61-3b0c-4326-8049-bdcdc910af72
 249           19   startup.nsh
 250       528384   u-boot-app.efi
 251        10181   NvVars
 252
 253    3 file(s), 0 dir(s)
 254
 255    => QEMU: Terminated
 256
 257
 258 Future work
 259 -----------
 260 This work could be extended in a number of ways:
 261
 262 - Add ARM support
 263
 264 - Add 64-bit application support (in progress)
 265
 266 - Figure out how to solve the interrupt problem
 267
 268 - Add more drivers to the application side (e.g.USB, environment access).
 269
 270 - Avoid turning off boot services in the stub. Instead allow U-Boot to make
 271   use of boot services in case it wants to. It is unclear what it might want
 272   though. It is better to use the app.
 273
 274 Where is the code?
 275 ------------------
 276 lib/efi
 277         payload stub, application, support code. Mostly arch-neutral
 278
 279 arch/x86/cpu/efi
 280         x86 support code for running as an EFI application and payload
 281
 282 board/efi/efi-x86_app/efi.c
 283         x86 board code for running as an EFI application
 284
 285 board/efi/efi-x86_payload
 286         generic x86 EFI payload board support code
 287
 288 common/cmd_efi.c
 289         the 'efi' command
 290
 291 --
 292 Ben Stoltz, Simon Glass
 293 Google, Inc
 294 July 2015
 295
 296 * [1] http://www.qemu.org
 297 * [2] https://github.com/tianocore/tianocore.github.io/wiki/OVMF