x86: U-Boot unknown version documentation (2023)

condition¶

U-Boot supports running asMaster-BootPayload on x86. So far only Link (Chromebook Pixel) andQEMUx86 targets have been tested, but should work on other x86 cards with minimal settings since coreboot takes care of most of the low-level details.

U-Boot is a main boot manager on the Intel Edison Board.

U-Boot also supports direct booting from the x86 boot vector without coreboot. In this case, called basic mode because it runs in "bare metal", U-Boot acts as a replacement for the BIOS. The following platforms are supported:

• Bayley Bay CRB

• Cherry Hill-CRB

• Congatec QEVAL 2.0 und conga-QA3/E3845

• Cougar Canyon 2 CRB

• CRB de Crown Bay

• Galilean

• Link (Pixel for Chromebook)

• Miniboard MAX

• Samus (Chromebook Pixel 2015)

• QEMU x86 (32 Bit und 64 Bit)

As for loading an operating system, U-Boot supports direct booting of a 32-bit or 64-bit Linux kernel as part of a FIT image. It also supports a compressed zImage. U-Boot supports loading an x86 VxWorks kernel. See README.vxworks for more details.

Create instructions for U-Boot as BIOS override (simple mode)¶

Building a ROM version of U-Boot (hereafter referred to as u-boot.rom) is a bit tricky, as it usually requires multiple binary blobs that are not in the U-Boot source tree. Because of this, the u-boot.rom build may throw some warnings if the required binary blobs (e.g. FSP) are not present.

CPU-Mikrocode¶

Modern CPUs often need a special bitstream calledmicrocodeIt needs to be loaded into the processor after boot for it to work properly. U-Bootha has already integrated these into the source tree as hex dumps.

Secondary school support¶

On a multi-core system, U-Boot runs on the boot processor (BSP). U-Boot can activate additional application processors (APs). In order to have an SMP kernel that recognizes all available processors, U-Boot must prepare configuration tables containing information for different CPUs before loading the operating system kernel. U-Boot currently supports generation of two types of tables for SMP, called Simple Firmware Interface (SFI) and multiprocessor (parliamentarians) tables. Writing to these two tables is controlled by two kconfig options, GENERATE_SFI_TABLE and GENERATE_MP_TABLE.

Controller-Modell¶

x86 switched to use Serial, GPIO, SPI, SPI Flash, Keyboard, Real Time Clock, USB driver model. The video is in progress.

device tree¶

x86 uses the device tree to configure the card, so CONFIG_OF_CONTROL must be enabled. Not all devices on the board are configured through the device tree, but more devices will be added over time. Look for these device tree source files in the arch/x86/dts/ directory.

useful commands¶

In keeping with U-Boot's philosophy of providing facilities for checking and adjusting internal configuration, there are several x86-specific commands that may be useful:

fsp

Displays information about the Intel Firmware Support Package (FSP). Only available on platforms using FSP, mostly Atom.

Iodine

Show I/O memory

now

Write I/O memory

mtrr

List and configure Memory Type Range (MTRR) registers. They are used to tell the CPU whether memory can be cached and, if so, which write-caching mode to use. U-Boot sets some reasonable values, but you can tweak them with this command.

Free boot¶

As an example of configuring your boot flow with U-Boot, here are instructions for booting Ubuntu from U-Boot. These instructions have been tested on a Minnowboard MAX with a SATA drive, but apply equally to other platforms and other media. There are really only four steps and it's a very simple script, but a more detailed explanation is provided here for completeness.

Note: It is possible to configure U-Boot to automatically boot with syslinux. You can also use the grub.cfg file (/efi/ubuntu/grub.cfg) to get the GUID. If you solve them, please post patches in this README.

First you need to install Ubuntu on an available hard drive. It should be possible to get U-Boot to boot from a bootable USB disk, but let's assume you used a different bootloader to install Ubuntu.

Use the U-Boot command line to find the UUID of the partition you want to boot. For example, our hard drive is SCSI device 0:

=> Liste der SCSI-Teile 0Partitionszuordnung für SCSI-Gerät 0 -- Partitionstyp: EFI Anfangsteil LBA Fin LBA-Nummer Attribute Typ GUID Partitions-GUID 1 0x00000800 0x001007ff "" attrs: 0x0000000000000000 Typ: c12a7328-f81f-11d2-ba4e4b-09e4b -09e4b -09e4b-09e4b-09e4b-09e4b-09e4b -4d59-408f-a9b0-fd497bc9291c 2 0x00100800 0x037d8fff "" attrs: 0x0000000000000000 type: 0fc63daf-8483-4772-8e79-3d69d8477de4 guid: 965c59ee-1822-4326-90d2-b02446050059 3 0x037d9000 0x03ba27ff "" attrs: 0x0000000000000000 type: 0657fd6d- a4ab-43c4-84e5-0933c84b4f4f tab: 2c4282bd-1e82-4bcf-a5ff-51dedbf39f17 =>

This shows that your SCSI drive has three partitions. Really long hexadecimal strings are called globally unique identifiers (GUIDs). You can search for "type".on here🇧🇷 On this disk the first partition is for EFI and in VFAT format (DOS/Windows):

=> fatls scsi 0:1 efi/0 file(s), 1 directory(s)

Partition 2 is "Linux File System Data" so it will be our root disk. It's in ext2 format:

=> ext2ls scsi 0:2<DIR> 4096 .<DIR> 4096 ..<DIR> 16384 perdido+encontrado<DIR> 4096 boot<DIR> 12288 etc<DIR> 4096 media<DIR> 4096 bin<DIR> 4096 dev <DIR> 4096 inicio<DIR> 4096 lib<DIR> 4096 lib64<DIR> 4096 mnt<DIR> 4096 opt<DIR> 4096 proc<DIR> 4096 raiz<DIR> 4096 executor<DIR> 12288 sbin<DIR> 4096 srv <DIR> 4096 sys<DIR> 4096 tmp<DIR> 4096 usr<DIR> 4096 var<SYM> 33 initrd.img<SYM> 30 vmlinuz<DIR> 4096 cdrom<SYM> 33 initrd.img.old=>

and if you look in the /boot directory you will see the kernel:

=> ext2ls scsi 0:2 /boot<DIR> 4096 .<DIR> 4096 ..<DIR> 4096 efi<DIR> 4096 grub 3381262 System.map-3.13.0-32-generic 1162712 abi-3.13.0-32 -generico 165611 config-3.13.0-32-generico 176500 memtest86+.bin 178176 memtest86+.elf 178680 memtest86+_multiboot.bin 5798112 vmlinuz-3.13.0-32-generico 165762 config-3.13.0-58-1generico 5 8 abirico 1 -generic 5823136 vmlinuz-3.13.0-58-generic 19215259 initrd.img-3.13.0-58-generic 3391763 System.map-3.13.0-58-generic 5825048 vmlinuz-3.13.0-58-generic .efi .firmado 28304443 initrd.img-3.13.0-32-generic=>

The 'vmlinuz' files contain a packed Linux kernel. The format is a kind of self-extracting compressed file mixed with some "installation" configuration data. Despite its size (it's >10MB uncompressed) it contains only a basic set of device drivers, enough to boot on most types of hardware.

The 'initrd' files contain a RAM disk. This is something that can be loaded into memory and appears as a hard drive in Linux. Ubuntu uses this to include many drivers for whatever hardware you might have. It loads before accessing the real root drive.

The numbers after the end of each file indicate the version. Here is the Linux version 3.13. You can find the source code for this in the Linux tree named v3.13. The '.0' allows additional Linux versions for debugging purposes, but this is not usually necessary. The '-58' is used by Ubuntu. Every time they release a new kernel, they increase this number. New versions of Ubuntu may include kernel patches to fix reported bugs. Stable cores can last for a few years, so this number can get quite high.

The .efi.signed kernel is signed for EFI Secure Boot. U-Boot has its own secure boot mechanism; I understandThat is&to be🇧🇷 Currently it cannot read .efi files.

To boot Ubuntu from U-Boot, do the following:

1. Define startup arguments. Use the GUID for the partition you want to boot:

   => setenv bootargs root=/dev/disk/by-partuuid/965c59ee-1822-4326-90d2-b02446050059 ro

This is where root= tells Linux the location of your root drive. The disk is specified by its GUID, using "/dev/disk/by-partuuid/", a Linux path to a "directory" containing all GUIDs found by Linux. At startup there is a file with this name in this directory. A device name can also be used here, see below.

2. Load the kernel. Since it's an ext2/4 filesystem, we can do the following:

   => ext2load scsi 0:2 03000000 /boot/vmlinuz-3.13.0-58-genérico

The address 30000000 is arbitrary, but there seem to be problems with using small addresses (sometimes Linux can't find the ramdisk). That's 48MB at the start of RAM (which is 0 in x86).

3. Load the ramdisk (to 64 MB):

   => ext2load scsi 0:2 04000000 /boot/initrd.img-3.13.0-58-generic

4. Start the kernel. We need to know the size of the ramdisk, but we can use a variable for that. U-Boot sets 'filesize' to the size of the last loaded file:

   => zboot 03000000 0 04000000 ${file size}

Type "help zboot" if you want to see what the arguments are. U-Boot on x86 is pretty verbose about booting a kernel. You should see these submarine messages:

Valid boot flag setting size = 0x00004400 Magic signature found with boot log version 2.0c Linux kernel version 3.13.0-58-generic (buildd@allspice) #97-Ubuntu SMP Wed Jul 8 02:56:15 UTC 2015 Creation of boot_params at 0x00090000 Loading of bzImage at address 100000 (5805728 bytes) Magic signature found First RAMdisk at linear address 0x04000000, size 19215259 bytes Kernel command line: "root=/dev/disk/by-partuuid/965c59ee- 1822 -4326-90d2-b02446050059 ro" starting core...

U-Boot reports some start times. This is most useful when you put the above commands in a script as it is faster:

Timer Summary in Microseconds: Mark Stage Transforms 0 0 RESET 241535 241535 Board_init_r 2421611 2180076 ID=64 2421790 179 ID=65 2428215 6425 Main_loop 48860584 46432

Now the kernel actually boots (if you want to examine the kernel boot message on the serial console, add "console=ttyS0,115200" to the kernel command line):

[ 0.000000] initializing cgroup subsys cpuset [ 0.000000] initializing cgroup subsys cpu [ 0.000000] initializing cgroup subsys cpuacct [ 0.000000] Linux Version 3.13.0-58-generic (buildd@allspice) (gcc Version 4.8.2 (Ubuntu 4.8-19ubuntu) ) #97-Ubuntu SMP Wed Jul 8 02:56:15 UTC 2015 (Ubuntu 3.13.0-58.97-generic 3.13.11-ckt22)[ 0.000000] Befehlszeile: root=/dev/disk/by-partuuid/ 965c59ee-1822 -4326-90d2-b02446050059 ro Console=ttyS0,115200

It goes on like this for a long time. Along the way, you'll see it snap your ramdisk:

[ 0.000000] RAMDISK: [mem 0x04000000-0x05253fff]...[ 0.788540] Attempt to unpack rootfs image as initramfs...[ 1.540111] Free memory initrd: 18768K (ffff880004000000 - ffff880005)...0).. .

Later he actually starts with this:

Start: Completed running /scripts/local-premount...

You should also see your startup disk:

[ 4.357243] scsi 1:0:0:0: Direct Access ATA ADATA SP310 5.2 PQ: 0 ANSI: 5 [ 4.366860] sd 1:0:0:0: [sda] 62533296 Logical blocks of 512 bytes: (32, 0 GB /29.8 GiB)[ 4.375677] sd 1:0:0:0: Generic SCSI SG0 Attached Type 0[ 4.381859] sd 1:0:0:0: [sda] Write protection is disabled[ 4.387452] sd 1:0 : 0 :0: [sda] Write Cache: On, Read Cache: On, does not support DPO or FUA[4.399535] sda: sda1 sda2 sda3

Linux found all three partitions (sda1-3). Fortunately the GUIDs are not printed. In step 1 above we could have used:

setenv bootargs root=/dev/sda2 ro

Instead of the GUID. However, if you add another unit to your board, the numbering may change, while the GUIDs may not. So if your boot partition becomes sdb2, it will still boot. For embedded systems where you only want to boot the first disk, you have this option.

The last thing you'll see in the console is the mention of plymouth (showing the Ubuntu splash screen) and lots of "startup" messages:

* Start mounting file systems on boot [OK]

After a pause you should see a login screen on your screen and that's it.

If you want to put this in a script you can use:

setenv bootargs root=UUID=b2aaf743-0418-4d90-94cc-3e6108d7d968 rosetenv boot zboot 03000000 0 04000000 \${filesize}setenv bootcmd "ext2load scsi 0:2 03000000 /boot/vmlinuz-3.13.0-58-t2generics;generics;generics; 0:2 04000000 /boot/initrd.img-3.13.0-58-generic; executar boot"saveenv

This is to tell the shell not to evaluate ${filesize} as part of the setenv command.

You can also incorporate this behavior into your build by coding the environment variables by adding this to minnowmax.h:

#undef CONFIG_BOOTCOMMAND#define CONFIG_BOOTCOMMAND \"ext2load scsi 0:2 03000000 /boot/vmlinuz-3.13.0-58-generic; " \"ext2load scsi 0:2 04000000 /boot/initrd.img-3.13.0-58-generic; " \"Execute initialization"#undef CONFIG_EXTRA_ENV_SETTINGS#define CONFIG_EXTRA_ENV_SETTINGS "boot=zboot 03000000 0 04000000 ${file size}"

and change the value of CONFIG_BOOTARGS in configs/minnowmax_defconfig to:

CONFIG_BOOTARGS="root=/dev/sda2ro"

Try SeaBIOS¶

SeaBIOSis an open source implementation of a 16-bit x86 BIOS. It can run on an emulator or natively on x86 hardware with U-Boot. With its help we can boot some operating systems that require 16-bit BIOS services, such as Windows/DOS.

As with U-Boot, we need to manually create a table for SeaBIOS to get system information (eg: E820). Unfortunately, the table has to follow the coreboottable format since SeaBIOS currently supports booting as a core boot payload.

To support loading SeaBIOS, U-Boot must be built with CONFIG_SEABIOS enabled. Booting from SeaBIOS is done using the U-Boot bootelf command as shown below:

=> tftp bios.bin.elf;bootelfUsing device e1000#0TFTP from server 10.10.0.100; our IP address is 10.10.0.108... Bytes transferred = 128748 (1f6ec hex)

bios.bin.elf is the SeaBIOS image built from the SeaBIOS source tree. SeaBIOS version 1.14.0 is currently being tested. To create the SeaBIOS image:

$ echo -e 'CONFIG_COREBOOT=y\nCONFIG_COREBOOT_FLASH=n\nCONFIG_DEBUG_SERIAL=y\nCONFIG_DEBUG_COREBOOT=n' > .config$ make olddefconfig$ make...Total Size: 128512 Fix: 69216 Free: 2560 (Uses 98.0% of 128KiB ) Create out/bios.bin.elf

This is currently being tested on a QEMU x86 target with U-Boot SeaBIOS daisy-chained loading to install/boot a Windows XP OS (eg Install Windows command below).

# Create a disk.img 10G as a virtual disk$ qemu-img create -f qcow2 disk.img 10G# Install a Windows XP operating system from an ISO image 'winxp.iso'$ qemu-system-i386 -serial stdio - bios u-boot.rom -hda disk.img -cdrom winxp.iso -smp 2 -m 512# Boot into a Windows XP operating system installed on the virtual disk $ qemu-system-i386 -serial stdio -bios u-boot . rom - hda disco.img -smp 2 -m 512

This is also tested on the Intel Crown Bay board with PCIe graphics card, SeaBIOS is booted, a GRUB is loaded from a USB stick and finally the Linux kernel.

If you are using the Intel Integrated Graphics Device (IGD) as the primary display device on your board, SeaBIOS must be manually patched in order for SeaBIOS to load and run your VGA ROM. SeaBIOS finds the VGA ROM through the PCI expansion ROM register, but the IGD device is not assigned its VGA ROM through this register. Your VGA ROM is packaged as part of u-boot.rom at a configurable flash address unknown to SeaBIOS. An example patch is required for SeaBIOS below:

diff --git a/src/optionroms.c b/src/optionroms.cindex 65f7fe0..c7b6f5e 100644--- a/src/optionroms.c+++ b/src/optionroms.c@@ -324,6 +324,8 @ @ init_pcirom(struct pci_device *pci, int isvga, u64 *fuentes) rom = deploy_romfile(archivo); else if (RunPCIroms > 1 || (RunPCIroms == 1 && isvga)) rom = map_pcirom(pci);+ if (pci->bdf == pci_to_bdf(0, 2, 0))+ rom = (struct rom_header *) 0xfff90000; if (! rom) // Nenhuma ROM präsentiert. Devolver;

Note: The patch above expects the IGD device to be on PCI b.d.f 0.2.0 and its VGA ROM on 0xfff90000 which corresponds to CONFIG_VGA_BIOS_ADDR in Minnowboard MAX. Change these two appropriately if your board doesn't.

development flow¶

These notes are for those who want to port U-Boot to a new x86 platform.

Since x86 CPUs boot from SPI Flash, an SPI Flash emulator is a good investment. Dediprog em100 can be used under Linux.

The em100 tool is available here:http://review.coreboot.org/p/em100.git

In Minnowboard Max you can use the following command line:

sudo em100 -s -p LOW -d u-boot.rom -c W25Q64DW -r

A clip suitable for connecting the SPI flash chip is here:http://www.dediprog.com/pd/programmer-accessories/EM-TC-8.

This allows you to replace SPI Flash content for development purposes. You can typically write to the em100 in about 1200ms, which is significantly faster than programming the actual flash device each time. The only major limitation of em100 is that it only supports SPI bus speeds up to 20MHz. This means that images must be configured to boot at this speed. This is an Intel specific feature, e.g. tools/ifttool has an option to set SPIspeed to the SPI descriptor region.

If your chip/board uses an Intel Firmware Support Package (FSP), it is very easy to install. For example, you can follow the implementation of Minnowboard Max. Hopefully you need to create new files similar to arch/x86/cpu/baytrail that support Bay Trail.

If you don't use an FSP, you have more freedom and more responsibility. Ivybridge support works this way, although you're still using a ROM for graphics and still have binary blobs of Intel code. You should try to support all major peripherals on your platform, including video and storage. If possible, use the device tree for configuration.

For microcode, you can use the microcode tool to create a suitable device tree file:

./tools/microcode-tool -d microcode.dat -m <modelo> criar

or if you only have header files and not the full Intel microcode.dat database:

./tools/microcode-tool -H BAY_TRAIL_FSP_KIT/Microcode/M0130673322.h \ -H BAY_TRAIL_FSP_KIT/Microcode/M0130679901.h -m todos crean

They are written to arch/x86/dts/microcode/ by default.

Note that it's possible to just add the microcode for your CPU if you know your model. U-Boot prints this information at startup:

CPU: x86_64, manufacturer Intel, device 30673h

so here we can use the M0130673322 file.

If your platform can display POST codes on two small 7-segment displays on the board, you can use C or assembler post_code() calls to monitor boot progress. This can be good for debugging.

If not, you can try to get the series working as soon as possible. The initial Debug Serial Port can be useful here. See setup_internal_uart() for an example.

During the U-Boot transfer, one of the important steps is to write the correct PIRQ routing information to the onboard device tree. Without them, device drivers in the Linux kernel will not work properly because the interrupt will not work. See submarinedocumentfor the Intel Break Router Device Tree Links. Here we have more details on Intel's proprietary Pirq routing below.

Intel, wall guide = <PCI_BDF (0, 2, 0) INTA WALL ...>;

As you can see, each entry has 3 cells. For the first one we need to describe all the board mounted devices. For SoC devices, there is usually a chapter on the chipset datasheet that lists all available PCI devices. For example, in Bay Trail, this is Chapter 4.3 (PCI configuration space). For the second, we can get the interrupt pin from the datasheet or from the hardware via the U-Boot shell. The reliable source is the hardware, as sometimes the chipset data sheet is not 100% up to date. Type 'pci header' plus the subboot shell pci bus/device/pci device function number below:

=> PCI Header 0.1e.1 Vendor ID=0x8086 Device ID=0x0f08... Interrupt Line=0x09 Interrupt Pin=0x04...

This shows that this PCI device is using the INTD pin as it reports 4 in the interrupt pin register. Repeat this until you get breakout pins for all devices. The last cell is the PIRQ line, which is associated with a specific interrupt pin. On the Intel chipset, the default boot mapping is INTA/B/C/D to PIRQA/B/C/D mapping. This can be changed via registers in the LPC bridge. So far, Intel FSP doesn't touch these registers, so we can annotate the PIRQ according to the standard mapping rule.

Once we get the PIRQ routing information from the device tree, U-Boot will automatically do the interrupt allocation and mapping. Now you can enable CONFIG_GENERATE_PIRQ_TABLE to test Linux kernel with i8259 PIC and CONFIG_GENERATE_MP_TABLE to test Linux kernel with local APIC and I/O APIC.

This script may be helpful. Feeding the U-Boot output 'pci long' generates a snippet of the device tree with the interrupt settings for each device (note that you need gawk 4.0.0):

$ cat console_output |awk '/PCI/ {device=$4} /interrupt line/ {line=$4} \ /interrupt pin/ {pin = $4; if (pin != "0x00" && pin != "0xff") \ {patsplit(device, bdf, "[0-9a-f]+"); \ printf "PCI_BDF(%d, %d, %d) INT%c PIRQ%c\n", strtonum("0x" bdf[1]), \stritonum("0x" bdf[2]), bdf[3 ], strtonum(pin) + 64, 64 + strtonum(pin)}}'

Example output:

PCI_BDF(0, 2, 0) INTA WALLCI_BDF(0, 3, 0) INTA WALL.

Portability Tips¶

ACPI support status¶

Advanced configuration and power interface (ACPI) aims to establish industry-standard interfaces that enable OS-driven configuration, power management, and thermal management of mobile, desktop, and server platforms.

Linux can boot without ACPI with the "acpi=off" command line parameter, but with ACPI the kernel gets the resources to handle power management. For Windows, ACPI has been a required firmware feature since Windows Vista. CONFIG_GENERATE_ACPI_TABLE is the configuration option to enable ACPI support in U-Boot. This requires the Intel ACPI compiler to be installed on your host to compile the ACPI DSDT table written in ASL format into AML format. You can get the compiler via "apt-get install iasl" if you're using Ubuntu, or download the source fromhttps://www.acpica.org/descargasput one together yourself.

Current ACPI support in U-Boot is basically complete. More optional features may be added in the future. The situation today is:

• Supports generation of RSDT, XSDT, FACS, FADT, MADT and MCFG tables.

• It only supports a static DSDT table compiled by the Intel ACPI compiler.

• Supports S0/S3/S4/S5, reboots and shuts down the operating system.

• Supports booting a preinstalled Ubuntu distribution via the zboot command.

• Supports installing and booting Ubuntu 14.04 (or later) from U-Boot using SeaBIOS using a legacy interface (non-UEFI mode).

• Supports installing and booting Windows 8.1/10 from U-Boot using SeaBIOS using a legacy interface (non-UEFI mode).

• Supports ACPI interrupts with SCI only.

Optional features:

• Dynamic insertion of AML bytecodes at runtime. We may need this to support SSDT table generation and DSDT repair.

• IMS support. Since U-Boot is a modern bootloader, we don't want to carry this old stuff over to U-Boot. The ACPI specification allows for a system that is not SMI compliant (a non-legacy system).

ACPI was originally enabled on BayTrail-based maps. The test was conducted by booting a preinstalled Ubuntu 14.04 from a SATA drive. Installing Ubuntu 14.04 and Windows 8.1/10 on and booting from a SATA drive is also tested. Most devices appear to be working fine and the card is able to respond to an OS reboot/shutdown command.

For other platform cards, the ACPI compliance status can be checked by checking the card's configuration files to see if CONFIG_GENERATE_ACPI_TABLE is set to y.

S3 sleep is a low-latency sleep state defined by the ACPI specification in which all system context is lost except for system memory. To test resuming from S3 with a Linux kernel, simply run "echo mem > /sys/power/state" and the kernel will put the card into the S3 state where the power is off. Then, when the power button is pressed again, U-Boot runs like cold boot and detects the sleep state via the ACPI register to see if it is S3. If so, that means we're operational. U-Boot is responsible for restoring the computer to the state it was in before it fell asleep. When everything is done, U-Boot discovers the activation vector provided by operating systems and jumps to it. To determine if ACPI S3 Digest is supported, check if CONFIG_HAVE_ACPI_RESUME is defined for that particular card.

Note that to test the S3 continuation with Windows, you must have the correct graphics driver installed for your platform; Otherwise, you won't find the "Sleep" option in the "Power" submenu of the Windows Start menu.

EFI support¶

U-Boot supports booting as a 32-bit or 64-bit EFI payload, e.g. with UFI. This is enabled with CONFIG_EFI_STUB to boot from both 32-bit and 64-bit UEFI BIOS. U-Boot can also be run as an EFI application using CONFIG_EFI_APP. The CONFIG_EFI_LOADER option, in which U-Boot provides an EFI environment for the kernel (i.e. completely replaces UEFI but provides the same EFI runtime services), is also supported. For example, we can even use the "bootefi" command to load a "u-boot-payload.efi", see test logs below on QEMU.

=> ide 0 3000000 load u-boot-payload.efi489787 bytes read in 138 ms (3.4 MiB/s) => bootefi 3000000Disk scan ide.blk#0...2 disks found WARNING: Boot without device tree# # EFI -Start application at 03000000...U-Boot EFI PayloadU-Boot 2018.07-rc2 (June 23, 2018 - 17:12:58 +0800)CPU: x86_64, Manufacturer AMD, 663hDRAM Device: 2 GiBMMC:Video: 1024x768x32Model: EFI x86 PayloadNet: e1000 : 52:54:00:12:34:56Warning: e1000#0 is using MAC address of ROMeth0: e1000#0No driver found Press any key to stop autostart: 0

verSubmarine and EFIjUEFI and U-Bootfor more information on EFI compatibility on submarines.

charging current¶

U-Boot can be chain-loaded from another bootloader such as Coreboot or Slim Bootloader. This is usually done by creating targets "coreboot" or "slimbootloader".

For example, we currently have a "main launch" target, but it executes very different code than the main targets like coral. There is very little in common between them.

It's handy to be able to boot the same U-Boot on a device, with or without a first-stage boot loader. For example, with chromebook_coral it is useful to test the ability to boot the same sub (complete with FSP) in both bare metal and coreboot. It allows you to check things like CPU speed, compare registers, ACPI tables and the like.

To do this, you can skip the boot process performed in the previous step with ll_boot_init() at the appropriate points. This works by setting a GD_FLG_NO_LL_INIT flag when U-Boot detects that it is running from a different bootloader.

With this function you can create a complete target and boot it from coreboot, for example.

Please note that this is a development feature only. It is not designed for use in production environments. Also, it is not currently part of the automated test, so it may fail in the future.

SMBIOS tables¶

To generate SMBIOS tables in U-Boot for use by the operating system, enable the CONFIG_GENERATE_SMBIOS_TABLE option. The easiest way to provide the values ​​to use is through the device tree. See for detailssmbios.txt.

Homework¶

• Audio-

• Chrome OS verified launch

  (Video) HACKERLOI.pdf