Skip to main content

How Tachyon Boots Ubuntu 24.04

Tachyon’s boot sequence involves multiple stages, from the moment power is applied to the point the Linux kernel starts. Understanding this process is useful for debugging boot issues, customizing bootloaders, or modifying kernel parameters. This page outlines the boot chain on Tachyon when running the Ubuntu 24.04 system image, including both Qualcomm-specific boot stages and the standard Linux boot components.

Boot ROM (PBL) – Initial Hardware Reset​

Everything begins with the Qualcomm Primary Bootloader (PBL) stored in ROM on the QCM6490. As soon as the device is powered on or reset, the Boot ROM (sometimes called Bootloader Stage 1) executes. The Boot ROM’s job is to initialize fundamental hardware (like power, clocks, DDR memory training) and then load the next stage bootloader from flash storage. It also implements Qualcomm’s Emergency Download Mode (EDL) – a special mode for recovery programming. If the Boot ROM doesn’t find a valid next stage, or if forced into EDL, the device will await instructions from a host PC to flash firmware.

XBL – Qualcomm Secondary Bootloader​

After the Boot ROM, Tachyon’s SoC launches Qualcomm’s eXtensible Bootloader (XBL). XBL (often referred to as the “UEFI loader” or OEM bootloader stage) is a proprietary second-stage bootloader. It is responsible for more advanced initialization, such as configuring DDR memory timing, setting up low-level drivers (UFS storage, etc.), and verifying cryptographic signatures on the next boot components (if secure boot is enforced). Essentially, XBL prepares the system to hand off control to an OS-level bootloader.

On Tachyon, XBL will load the next bootloader stage from the UFS (internal storage) using its UEFI loading magic. In the factory image (Ubuntu 20.04), this next stage was Qualcomm’s ABL (Android Boot Loader) which acted within this quasi-UEFI environment. In the Ubuntu 24.04 open build, we replace ABL with U-Boot but loaded in a similar manner.

U-Boot – Open Source Bootloader​

U-Boot (aka Das U-Boot!!) is the primary bootloader for Tachyon’s Ubuntu 24.04 system. Particle’s Tachyon uses U-Boot in place of the proprietary Qualcomm ABL/UEFI for this new build. U-Boot is stored within the XBL.elf file.

When XBL transfers control to U-Boot, the following happens:

  • U-Boot executes in ARM 64-bit mode, initializing any remaining board-specific peripherals required for boot. This includes things like turning on regulators, setting up the serial console (for debug output), and loading the device tree (hardware description).
  • Device Tree (DTS): U-Boot carries (or loads a Device Tree Blob if you so configure it) that describes Tachyon’s hardware (CPU, memory, buses, connected devices). This DTB is later passed to the Linux kernel. Tachyon’s device tree is open for modification (found in the tachyon-u-boot repo as a subtree), which allows developers to enable or adjust support for various hardware components.
  • U-Boot on Tachyon is configured to behave as a UEFI-compatible environment. It implements the UEFI API enough to load standard EFI executables. This is important because it allows us to use a stock Ubuntu GRUB bootloader next.

At this stage, you might see U-Boot output on the debug UART (if you have access to the serial console) and you can interrupt the boot process by pressing a key. It can be useful for debugging boot issues. By default, U-Boot will automatically proceed to launch the next component (with minimal delay, as this is an embedded device intended to boot quickly).

GRUB – Bootloader Manager​

Tachyon’s storage includes an EFI System Partition – a small FAT partition that holds EFI programs and configurations. In our Ubuntu images, we place the standard GNU GRUB bootloader here (just like on a PC).

Here’s what happens:

  • U-Boot acts as a UEFI firmware and looks at the EFI partition on the disk. It finds the GRUB EFI binary.
  • U-Boot loads and executes GRUB as an EFI application. From this point, GRUB takes over the boot process.

GRUB’s role: GRUB is a more feature-rich boot manager. It reads its configuration (grub.cfg) from the EFI partition or the Ubuntu /boot directory. In Tachyon’s Ubuntu 24.04 setup, GRUB will:

  • Display nothing, unless interrupted with a key, in which case it shows a console UI – typically Tachyon is configured to boot automatically without user selection.
  • Load the system partition from the grub.cfg file and mount the root filesystem
  • Locate the Linux kernel from the root filesystem. For example, a kernel file might be /boot/vmlinuz-6.x.y-z-tachyon and an initrd /boot/initrd.img-6.x.y-z-tachyon.
  • Load the kernel and initrd into memory.
  • Provide the kernel with necessary parameters via the kernel command line and DTS file.

Kernel Command Line: GRUB (or U-Boot in some cases) supplies a set of boot arguments to the Linux kernel. These might include:

  • The root filesystem location (e.g., root=/dev/mapper/... or appropriate partition).
  • Console settings (e.g., console=ttyMSM0,115200 to enable serial console output).
  • Any debug flags or hardware workarounds needed. By default, our Tachyon 24.04 images set the command line to ensure the console is accessible and to integrate with any special needs (like specifying the Android binder devices if needed, or modem TTY ports). Developers can modify the command line by editing GRUB’s config if necessary (for example, to enable additional debug like earlyprintk or to disable a feature).

Linux Kernel and Init Process​

With the kernel image and initrd loaded, GRUB hands control to the Linux kernel. At this point:

  • The custom Tachyon kernel (based on a modern Linux version) takes over, identifying hardware with the provided Device Tree.
  • Early in kernel boot, drivers for various components initialize. The kernel will bring up CPU cores, memory, and then initialize peripheral drivers (for Wi-Fi, USB, etc.). Many of these drivers will load firmware files from the filesystem (thanks to the work of earlier overlays, the needed firmware binaries are present in /lib/firmware on the rootfs).
  • The initrd (initial RAM disk) helps bootstrap the real root filesystem. Ubuntu’s initramfs will handle things like setting up filesystems, potential encryption or LVM (though Tachyon uses straightforward partitions by default), and then pivot to the actual root filesystem.

Finally, the Ubuntu userland comes up:

  • systemd (the init system) begins running, bringing up all services.
  • If it’s a headless image, you’ll have networking services, SSH server (if enabled), etc. If it’s a desktop image, a graphical login might start on the display (once display support is working).
  • You can log in (either via serial console or via ADB over USB) using the default credentials provided by Particle for these images (see documentation for default username/password or use the one you set during initial setup).

This chain marries Qualcomm’s secure boot flow with standard Linux boot components. The use of U-Boot and GRUB means we stay close to typical Linux distributions, which makes it easier to maintain and customize.

With the boot process understood, you might be curious which features are functional in this early Ubuntu 24.04 build, and which are still being developed. The next page provides a detailed status of “what’s working” and what’s not.