Getting Started with RHEL 10 on RISC-V Platforms

Updated -

This guide provides instructions and information for installing Red Hat Enterprise Linux (RHEL) 10 Developer Preview on RISC-V platforms.

It was originally published in May 2025, and has been updated in June 2026 and most recently October 2026 to reflect the changes introduced with subsequent RHEL 10 for RISC-V Developer Preview images. The information in this article is about the October 2026 image specifically, though most of it will also apply to earlier releases.

About the Hardware and Software

In addition to the SiFive HiFive Premier P550 which was enabled in our original images, the refreshed developer preview image brings enablement for the following devices:

  • SpacemiT V100
  • SpacemiT K3 (Pico-ITX and CoM260)
  • SpacemiT K1
  • UltraRISC UR-DP1000 (Milk-V Titan)

This developer preview allows developers to explore porting software to the riscv64 instruction set architecture (ISA). Key characteristics of this developer preview software include:

  • It is not fully tested by Red Hat and is not intended for production environments or use cases.
  • Red Hat does not provide technical support for developer preview releases, components, or features.
  • There may be no migration path from the developer preview to a general availability (GA) release should one become available; a full GA installation might be required, potentially leading to data migration needs or data loss.
  • Participation is optional, and versions may change or be removed at any time.
  • Red Hat is not obligated to support developer preview functionality now or in the future.

For details on Red Hat's developer preview program, please consult their support scope: Red Hat Developer Preview Support Scope.

Note that this developer preview comes with a number of known limitations. Please familiarize yourself with the contents of the Limitations, Known Issues and Considerations section below before attempting to run RHEL 10 on the board.

What’s new in the refreshed RHEL 10.2 for RISC-V Developer Preview image

The updated RHEL 10.2 for RISC-V Developer Preview image contains a number of changes compared to the previous image

  • Updated platform support: the updated image brings enablement for new hardware offerings from SpacemiT and UltraRISC.
  • Updated software components: all packages in the Developer Preview have been updated to match what RHEL 10.2 ships on other architectures. In particular, Go and Rust have been updated to version 1.26 and 1.92 respectively.

Preliminary Steps

Choosing a Storage Option

The compatible boards vary in storage options. You should pick the one that best suits your use case.

  • NVMe drive: Unlocks the fastest storage performance. Most boards have a dedicated M.2 M-key slot which can be used for one. The SiFive HiFive Premier P550 lacks an M.2 slot but can be used with an adapter to connect an M.2 NVMe drive to its PCIe slot, which prevents installing a video card but is a good choice for headless systems such as build servers.
  • SATA drive: The SiFive HiFive Premier P550 board offers a SATA port. Connecting a SATA SSD to it is probably the best all-around option for this board, since it allows very good performance while leaving the PCIe slot available so that a GPU can be installed in it. Most other boards do not have an onboard SATA controller.
  • USB drive: Average performance and reliability; takes up one of the board's USB ports. Should only be used for testing or as a way to get the OS image flashed to a better storage device.
  • microSD card: Similar performance and reliability characteristics to USB drive. Should only be used for testing or as a way to get the OS image flashed to a better storage device. SiFive HiFive Premier P550, Milk-V Jupiter, and SpacemiT K3 CoM260 have a dedicated microSD card slot. Other boards can use microSD with a USB adapter.

What You Will Need

Depending on the choice of storage, you are going to need one of the following:

  • M.2 2280 NVMe drive
    • Recommended for installation: NVMe USB enclosure or adapter
    • Needed for SiFive HiFive Premier P550: M.2 PCIe slot adapter
  • SATA drive and SATA cable
    • Recommended for installation: SATA USB enclosure or adapter
  • USB drive
  • microSD card
    • Recommended for installation: USB card reader

The storage media needs to have a capacity of at least 16GB.

Regardless of the choice of storage, you are also going to need all of the following:

  • SpacemiT K3 (Pico-ITX)
    • USB Type-C PD power supply (60W or higher)
    • USB to UART cable (included in the box)
  • SpacemiT K3 (CoM260)
    • 12V DC 5525 power supply (5A/60W or higher)
    • USB to UART cable (included in the box)
  • SpacemiT K1 (Milk-V Jupiter)
    • ATX power supply or 12V DC /5525 power supply (3A/36W or higher)
    • USB to UART cable
  • UltraRISC UR-DP1000 (Milk-V Titan)
    • ATX power supply or 12V DC 5525 power supply (3A/36W or higher)
    • USB-C to USB-A cable (for serial console)
  • SiFive HiFive Premier P550
    • ATX power supply. See SiFive’s official compatibility list.
    • USB-C to USB-A cable (for serial console, included in the box)

The built-in GPU is not enabled for any RISC-V boards in RHEL. For machines that have a PCIe slot, you optionally may use the graphical interface by adding a video card. This is not necessary if you prefer to use the system entirely through the serial console instead. Using a graphical interface requires the following:

Board Setup

Follow the board vendor’s setup guide to connect your board to the power supply, storage drive, serial console, and optionally install it inside a case.

Connecting To the Board's Serial Console

Depending on your board, use a USB UART adapter or USB Type-C cable to connect the board’s console interface to a USB port on another computer you will use to control it.

On Linux, these adapters appear as a TTY device that is often named something like /dev/ttyUSB0 or /dev/ttyACM0 and should have a stable path under /dev/serial/by-id/. On Windows, they appear as COM ports.

Note that SiFive HiFive Premier P550 exposes four serial ports for SoC JTAG, MCU JTAG, SoC UART, and MCU UART in that order. For this board, the SoC UART at /dev/serial/by-id/usb-FTDI_Quad_RS232-HS-if02-port0 is the interface that can be used to control the console for RHEL 10 Developer Preview.

Once you've identified the TTY device name, use a terminal emulator like picocom, screen, or minicom on Linux, or PuTTY on Windows, to connect to it. The terminal emulator needs to be configured as follows:

  • Baud Rate: 115200
  • Data Bits: 8
  • Parity: None
  • Stop Bits: 1
  • Flow Control: None

Example command for Linux:

$ picocom -b 115200 /dev/serial/by-id/usb-FTDI_Quad_RS232-HS-if02-port0

Use Ctrl-A Ctrl-X to quit picocom.

Upgrading the Board's Firmware

Before you can run RHEL 10 on your RISC-V machine, you need to ensure that you're running the latest version of the firmware provided by the vendor.

SpacemiT K3 (Pico-ITX and CoM260)

Neither the K3 Pico-ITX User Guide nor the K3 CoM260 User Guide explicitly document the steps needed to upgrade the board’s firmware; the expectation is that firmware updates will be delivered along with other updates for the default operating system, Bianbu OS. If you are running a fully up to date version of Bianbu OS, you can assume that your firmware is up to date as well.

Note: RHEL 10 for RISC-V has only been confirmed to work with the U-Boot variant of the firmware. If you are using the edk2 variant (referred to as “UEFI preview” in the vendor documentation), you will need to replace it with the U-Boot variant before proceeding.

SpacemiT K1 (Milk-V Jupiter)

The documentation for Milk-V Jupiter does not explicitly document the steps needed to upgrade the board’s firmware; the expectation is that firmware updates will be delivered along with other updates for the default operating system, Bianbu OS. If you are running a fully up to date version of Bianbu OS, you can assume that your firmware is up to date as well.

SiFive HiFive Premier P550

At the time of this writing, the latest available firmware is 2026.08.00-HFP550, but a more recent one might be available from SiFive's GitHub account.

For detailed instructions on how to upgrade the board's firmware, follow chapter 2 of the HiFive Premier P550 Image Update Procedure document.

Note: you should only follow the instructions up until the point where bootloader_ddr5_secboot.bin is flashed: writing an updated OS image to the board's eMMC is not necessary.

Accessing the U-Boot shell

Once the latest version of the firmware has been installed, reboot the board and drop into the U-Boot shell. The U-Boot prompt looks like this:

=>

The steps necessary to access the U-Boot shell vary slightly.

SpacemiT K3 (Pico-ITX and CoM260)

With the machine powered off, connect to the serial console. Press the ‘s’ key and, while keeping it pressed, power on the machine. Wait for the initial output from the firmware to scroll by; after a few seconds, you will be presented the U-Boot prompt. You can now release the ‘s’ key and start typing U-Boot commands.

SpacemiT K1 (Milk-V Jupiter)

Follow the same steps described above for SpacemiT K3 (Pico-ITX and CoM260).

SiFive HiFive Premier P550

Connect to the serial console and power the machine on. Wait for the initial output from the firmware to scroll by; after a few seconds, the message

Hit any key to stop autoboot:  2

will be displayed. Press any key, for example ‘s’ or Enter, before the countdown runs out to access the U-Boot prompt.

Firmware configuration

Once you’ve reached the U-Boot prompt, run the following commands:

=> env default -f -a
=> env save

This will restore U-Boot's configuration to its default, known good state. From there, the configuration steps are machine-specific.

SpacemiT K3 (Pico-ITX)

Run the following commands to configure the machine to boot into RHEL 10:

=> env set fdtfile 'spacemit/k3-pico-itx.dtb'
=> env set bootdev 'nvme 0'
=> env set bootcmd 'ping 127.0.0.1; nvme scan; load ${bootdev}:1 ${fdt_addr_r} dtb/${fdtfile}; load ${bootdev}:1 ${kernel_addr_r} EFI/redhat/shimriscv64.efi; bootefi ${kernel_addr_r} ${fdt_addr_r};'
=> env save
=> boot

The above assumes that you are going to run RHEL 10 from NVMe.

SpacemiT K3 (Com260)

Run the following commands to configure the machine to boot into RHEL 10:

=> env set fdtfile 'spacemit/k3-com260-ifx.dtb'
=> env set bootdev 'nvme 0'
=> env set bootcmd 'ping 127.0.0.1; nvme scan; load ${bootdev}:1 ${fdt_addr_r} dtb/${fdtfile}; load ${bootdev}:1 ${kernel_addr_r} EFI/redhat/shimriscv64.efi; bootefi ${kernel_addr_r} ${fdt_addr_r};'
=> env save
=> boot

The above assumes that you are going to run RHEL 10 off the NVMe drive. If you are going to boot off an SD card instead, replace the second command with:

=> env set bootdev 'mmc 0'

SpacemiT K1 (Milk-V Jupiter)

Run the following commands to configure the machine to boot into RHEL 10:

=> env set fdt_addr_r 0x31000000
=> env set fdtfile 'spacemit/k1-milkv-jupiter.dtb'
=> env set bootdev 'nvme 0'
=> env set bootcmd 'nvme scan; load ${bootdev}:1 ${fdt_addr_r} dtb/${fdtfile}; load ${bootdev}:1 ${kernel_addr_r} EFI/redhat/shimriscv64.efi; bootefi ${kernel_addr_r} ${fdt_addr_r};'
=> env save
=> boot

The above assumes that you are going to run RHEL 10 off the NVMe drive. If you are going to boot off an SD card instead, replace the third command with:

=> env set bootdev 'mmc 0'

SiFive Hifive Premier P550

Optional: By default, the firmware displays its output both on the serial console and over the integrated GPU (which is not enabled in RHEL 10). Run the following commands to limit firmware output to the serial console only:

=> env set stdout serial
=> env set stderr serial
=> env save

This will make the GRUB menu more responsive.

Preparing the Storage Device

RHEL 10 for RISC-V Developer Preview is distributed as a disk image that you will write to the target storage media.

Some details will be slightly different depending on your choice of storage option, but the overall procedure remains the same. It is necessary to have a computer running Linux or Windows to prepare the storage media.

Downloading and Uncompressing the RHEL 10 Image

Specific download links for the RHEL 10 for RISC-V Developer Preview are not included in this document. Please view the RHEL 10 for RISC-V Developer Preview page on the Red Hat Developer Portal for more information.

The image file will be compressed (i.e. have a .img.xz extension). You'll need to decompress it first.

On Linux:

Use unxz like so:

$ unxz --keep --threads=0 rhel-10.2-riscv64-dev-preview-update.img.xz

On Windows:

A free and open-source tool like 7-Zip can be used.

Writing the Image To the Storage Device

Important: this process will overwrite all data on the target storage device. Ensure you have selected the correct device.

On Linux:

You can use the dd command to write the RHEL 10 image to the target storage device.

  • Attach the target storage device into your computer; this will usually involve using a USB enclosure of some kind.
  • Identify the storage device: Open a terminal and use a command like lsblk or sudo fdisk -l to identify the device name (e.g., /dev/sda, /dev/sdb). Be extremely careful to identify the correct device.
  • Unmount the storage device: If any partitions on the target storage device were automatically mounted, unmount them. For example, if /dev/sdb1 is mounted, use sudo umount /dev/sdb1.
  • Write the image: Use sudo dd iflag=fullblock oflag=direct bs=4M status=progress conv=fsync if=/path/to/rhel-10.2-riscv64-dev-preview-update.img of=/dev/sdX. Replace /path/to/rhel-10.2-riscv64-dev-preview-update.img with the actual path to the decompressed RHEL 10 image file and /dev/sdX with the correct device name for the target storage device. Verify this step with extreme caution! Writing to the wrong device can destroy data on your system.
  • Wait for completion: The process can take some time.

On all operating systems:

You can use a tool like balena Etcher to write the RHEL 10 image to the target storage device.

  • Attach the target storage device into your computer; this will usually involve using a USB enclosure of some kind.
  • Launch balena Etcher.
  • Click "Flash from file" and select the decompressed RHEL 10 image file (rhel-10.2-riscv64-dev-preview-update.img).
  • Click "Select target" and choose the target storage device. Make sure that the correct device is selected.
  • Click "Flash!" to begin the writing process.
  • Wait for the process to complete. This can take some time.

Alternative Installation Methods

If an OS is already installed and running on the target system, you can use it to flash the RHEL 10 Developer Preview image to another storage device. This may be particularly useful for flashing to non-removable on-board storage such as eMMC/UFS or for flashing to an NVMe or SATA drive without relying on a USB adapter to connect it to another computer. After confirming that no filesystems on the target drive are already mounted, this flash can be performed with a command such as:

$ sudo dd iflag=fullblock oflag=direct bs=4M status=progress conv=fsync if=/path/to/rhel-10.2-riscv64-dev-preview-update.img of=/dev/nvme0n1

If you go this route, make sure that the storage device that you've used for writing the image is either detached from the board or cleared out before attempting to boot into RHEL 10.

Some boards offer other methods to flash storage drives from a BMC, U-Boot prompt, or USB recovery mode. These may be used to flash the RHEL 10 Developer Preview image.

UltraRISC UR-DP1000 (Milk-V Titan)

This machine uses edk2 instead of U-Boot as the firmware, so the DTB file has to be loaded using a different mechanism (via GRUB).

To enable this, mount the second partition of the device to which you have just written the RHEL 10 disk image:

$ sudo mount /dev/sdX2 /mnt

Note: if you unplug the disk from the computer and plug it back in, your operating system might automatically mount the partition for you. If that is the case, do not attempt to mount the second partition again and instead replace /mnt with the directory that your operating system has chosen to install the partition into in the instructions below.

Now open the configuration file for the default bootloader entry in your favorite editor, for example:

$ sudo vi /mnt/boot/loader/entries/31855cdd7e834334bd7a16c981ad2b6a-6.12.0-264.rv.6.el10.riscv64.conf

The file will contain the following text at the very bottom:

#Uncomment the next line to boot on Milk-V Titan
#devicetree /boot/dtb-6.12.0-264.rv.6.el10.riscv64/ultrarisc/dp1000-milkv-titan.dtb

Uncomment the last line to enable loading the Milk-V Titan DTB file via GRUB. Save the file and unmount the partition:

$ sudo umount /mnt

Your storage drive is now ready to be used on Milk-V Titan.

Initial System Setup

Boot Process

RHEL 10 will boot into a graphical session by default. You will only be able to use the graphical session if you have installed a PCIe graphics card on a machine that supports it, since the onboard GPU is not enabled.

The display connected to the PCIe graphics card will remain blank for the first minute or so after the board has been turned on. This is expected: Linux only initializes the GPU somewhat late in the boot process, and no output will be produced before then.

If you are connected to the board's serial console (as documented in the earlier section) you will be able to see early boot messages. Additionally, you will be able to interact with the U-Boot firmware and the GRUB bootloader. It is recommended to be connected to the serial console at least for the first boot.

Login Information

The RHEL 10 for RISC-V Developer Preview image comes with a default unprivileged user.

The login credentials for this user are:

  • Username: redhat
  • Password: redhat

Upon logging in for the first time, either via serial console or the graphical display manager, you will be prompted to choose your own secure password.

The redhat user is a member of the wheel group, so it can use sudo to perform administrative tasks.

If for some reason the default user login fails or you need to perform recovery tasks requiring root access without knowing the redhat user's password, refer to Appendix A: Manual Root Password Setup.

Post-Installation Tasks

Running Container Images with Podman

You can load container images directly via URL using Podman. For example, to load a Fedora container image:

$ podman load -i https://dl.fedoraproject.org/pub/alt/risc-v/release/44/Container/riscv64/images/Fedora-Container-Base-Generic-44-20260604.0.riscv64.oci.tar.xz

The initial load might appear stuck but will complete if you wait. Once loaded, you can run it:

$ podman run --rm -it localhost/fedora:44

For images that already have riscv64 support in their registry (e.g. Alpine), no special steps are typically necessary.

Limitations, Known Issues and Considerations

This Developer Preview comes with a number of known limitations.

  • No access to package repositories: The disk image, as provided, comes with a reasonably large selection of software pre-installed: this includes a full GNOME desktop, the Firefox web browser, and a number of compilers and interpreters along with the respective language-specific package managers and build tools. However, access to package repositories is not configured, so it's not possible to install additional packages the way you normally would on RHEL. Similarly, no updates are planned at this time.
  • Boot Feedback: The boot process provides limited feedback without a serial console. The console log shows detailed messages from firmware, U-Boot, GRUB, and the kernel.
  • Bootloader Interaction: Interaction with the firmware and bootloader (U-Boot, GRUB) happens exclusively via the serial console.
  • Onboard video (HDMI): The onboard GPU is not enabled in this Developer Preview and there is no video output detected from the onboard HDMI port. If you want to use a graphical session, you will need to install a discrete GPU in the board's PCIe slot (on boards that support it).
  • Onboard audio (analog jacks): The onboard audio controller is not enabled in this Developer Preview. Audio output via the HDMI port of a PCIe graphics card will work if one is installed, or a USB audio interface can be used.

The following issues have been found during testing:

  • Missing RTC (Real-Time Clock) functionality: The Real-Time Clock does not maintain time across reboots at the OS level. While the Baseboard Management Controller (MCU) can set and retrieve the time, there is an issue with the operating system consistently persisting or advancing this time.

Additional considerations:

  • Shutdown: Always perform a graceful shutdown (e.g., poweroff or shutdown -h now commands) to prevent filesystem corruption. Wait for a confirmation message like "System halted" or "Power down".

The following known issues are board-specific.

SpacemiT K3 (Pico-ITX and CoM260)

  • Reboot does not work: Shut down the machine and power it back on instead.

UltraRISC UR-DP1000 (Milk-V Titan)

  • Firmware and bootloader cannot be accessed via serial console: the only way to interact with the machine before Linux is loaded is through a physical monitor, which in turn requires a GPU to be installed in the board’s PCIe slot. If the storage media has been prepared correctly, the board will automatically boot into RHEL 10 once powered on, so interacting with the firmware or bootloader is generally not required for regular usage.
  • No stable IP address by default: Due to the way the DTB file is loaded on this board, the network interface will not use the factory-assigned MAC address and will instead have a different one every single time the machine is restarted. To make it so the IP address remains consistent across reboots, run the following command: sudo nmcli connection modify eth0 ethernet.cloned-mac-address stable
  • Instability under prolonged load: The machine performs quite well under regular conditions; however, running jobs that keep all its CPU cores busy for several hours is likely to eventually trigger the following error: fatal glibc error: ../nptl/pthread_mutex_lock.c:88 (__pthread_mutex_cond_lock): assertion failed: mutex->__data.__owner == 0
  • Running Podman crashes the machine: Even just invoking the command will immediately cause an unrecoverable failure. Unfortunately, since the graphical terminal emulator included in RHEL 10 (Ptyxis) implements native Podman support, this results in that utility being unusable on Milk-V Titan.

Community and Support

Document References

Appendix A: Manual Root Password Setup (If Default User Login Fails)

This appendix describes how to set the root password if the default redhat user login is unsuccessful or if direct root access is required for recovery. This involves interrupting the bootloader (GRUB) to modify kernel parameters and boot into single-user mode.

  1. Connect to Serial Console: Ensure your system serial console (/dev/serial/by-id/usb-FTDI_Quad_RS232-HS-if02-port0 or its equivalent on your OS) is connected and your terminal emulator is active.
  2. Power On and Interrupt GRUB: Power on the system. Watch the serial console output closely. After U-Boot loads the EFI application, the GRUB menu will appear. Quickly use the arrow keys to stop the automatic boot countdown. Select the primary RHEL entry (usually the first one).
  3. Edit Boot Arguments: Press the e key to edit the selected boot entry's commands.
  4. Modify Kernel Line: You will see several lines. Locate the line that starts with "linux". This line specifies the kernel image and its parameters. Navigate to the end of this line.
  5. Add rd.break: Append "rd.break" to the end of the linux line. For example, if it ends with "rhgb quiet", change it to "rhgb quiet rd.break".
  6. Boot with Modified Arguments: Press Ctrl+x or F10 to boot with these modified arguments.
  7. Access Root Shell: The system will boot and then drop you into a root shell, often within the initramfs environment, with a prompt like switch_root:/#.
  8. Remount Root Filesystem: The root filesystem is mounted read-only at /sysroot. You need to remount it as read-write: mount -o remount,rw /sysroot.
  9. Chroot into System: Change the root to /sysroot to operate on your actual system files: chroot /sysroot. Your prompt should change, e.g., sh-5.x# or similar.
  10. Set Root Password: Now you can change the root password by running: passwd root. Enter and confirm the new strong password. If needed, you can also reset the redhat user's password here by running: passwd redhat.
  11. Ensure SELinux Relabeling: If SELinux is enabled (default in RHEL), create the /.autorelabel file to force a full filesystem relabel on the next boot. This is important after manual filesystem modifications. touch /.autorelabel
  12. Exit and Reboot: Type exit to leave the chroot environment (back to the switch_root:/# prompt). Type reboot or exit again. If exit doesn't trigger a reboot, reboot -f can be used, but a normal reboot is preferred.
  13. Normal Boot: The system should now boot normally. If SELinux relabeling was triggered, it might take longer for the first boot. You can then log in as root with the password you just set, or as the redhat user if you reset its password.

This procedure allows you to regain administrative access to the system.

Appendix B: Known Working GPUs

The following GPUs have been tested by Red Hat and are known to work with the RHEL 10 for RISC-V Developer Preview:

  • AMD Radeon RX 550
  • AMD Radeon RX 560
  • AMD Radeon RX 570

Other GPUs, especially ones that are directly supported by the Linux kernel without the need for additional drivers to be installed, might work as well.

Appendix C: Understanding Key Differences: RISC-V vs. x86_64

The development environment on the HF106 may differ from what many Red Hat users are accustomed to, primarily due to architectural differences between RISC-V and x86_64 systems.

Firmware and System Configuration:

  • In x86_64 systems, initial host configuration is managed by system firmware (historically BIOS, now commonly UEFI). UEFI acts as the interface between hardware and the operating system, utilizing the Advanced Configuration and Power Interface (ACPI) to abstract hardware configuration and inform the OS about available hardware.
  • Systems not supporting ACPI, common in the current RISC-V ecosystem like the SiFive HiFive Premier P550 with this RHEL 10 for RISC-V Developer Preview, use a "device tree." This is a data structure (typically a text file compiled into a binary blob, .dtb) that defines the platform's hardware components and peripherals for the operating system kernel at runtime. While future RISC-V server platforms aim to necessitate ACPI, most current systems rely on device trees. For a RHEL user, this means the kernel learns about the hardware through the device tree rather than ACPI tables.

Appendix D: The Boot Flow Explained

The boot process on a RISC-V system like the P550 with the RHEL 10 Developer Preview involves several stages, culminating in the Linux kernel taking control. The provided console log indicates an EFI-based boot process initiated by U-Boot.

  1. Reset and Initial Bootloader (ZSBL/ROM): When the system is powered on or reset, a dedicated security processor within the system-on-chip (SoC) begins execution from its reset vector, passing control to a zero stage bootloader (ZSBL) located in its internal read-only memory (ROM). The ZSBL performs essential, minimal hardware initialization. It reads hardware settings, such as the boot select DIP switches (SW1), to determine the source for the next stage bootloader.
  2. Loading U-Boot and OpenSBI from SPI Flash: With the Boot Select DIP switch (SW1, #28 in Figure 1-1 of the SiFive HiFive Premier P550 Getting Started Guide) set to "0010" (DIP switch 1 OFF, 2 ON, 3 OFF, 4 OFF, read MSB first with ON=0, OFF=1), the ZSBL loads the main bootloader environment from the board's SPI flash memory. This environment contains firmware to run on the security processor, and a payload for initializing the LPDDR5 D-RAM. Once the firmware has initialized the main memory, U-Boot (Das U-Boot) and OpenSBI can be loaded into memory from the SPI flash and the main CPU can come out of reset to run them.
    • Privilege Levels: RISC-V defines several privilege levels. M-mode (machine mode) is mandatory and most privileged, having direct hardware access. S-mode (supervisor-mode) is for operating systems, and U-mode (user-mode) is for applications.
    • OpenSBI (Open Supervisor Binary Interface): OpenSBI initializes first, running in M-mode. It provides a Supervisor Execution Environment (SEE) and an M-mode runtime System Binary Interface (SBI) that the S-mode operating system kernel uses for low-level hardware access (e.g., console I/O, inter-processor interrupts, timer programming). This separation simplifies OS porting and virtualization. The console log shows "OpenSBI v1.4" initializing.
  3. U-Boot Execution: After OpenSBI, U-Boot (version 2024.01 as per the console log) takes control. U-Boot performs further hardware initialization, including initializing the ethernet ports and probing USB, SATA, and PCIE to look for storage devices. It then prepares to boot an operating system by scanning the potential boot media it found in a specific order. The default scan order configured in U-Boot is MMC1 (microSD Card), USB, NVMe, SATA, then MMC0 (eMMC).
  4. EFI Boot with GRUB (for RHEL 10): For the RHEL 10 Developer Preview image, U-Boot utilizes its EFI (Extensible Firmware Interface) support. The console log shows: "** Booting bootflow 'sata@0x50420000.bootdev.part_1' with efi" followed by "Booting /efi\boot\bootriscv64.efi". This indicates U-Boot locates and executes an EFI boot application (GRUB, in this case bootriscv64.efi) from the EFI System Partition (ESP) on the storage device.
  5. GRUB and Kernel Load: GRUB (the Grand Unified Bootloader, version 2.12 as per the log) loads and typically presents a boot menu. This menu allows the user to select the RHEL kernel (e.g., "Red Hat Enterprise Linux (6.12.0-89.rv.0.el10.riscv64) 10.0 (Coughlan)") or other options like a rescue kernel or UEFI firmware settings. Upon selection (or timeout), GRUB loads the specified Linux kernel and its associated initial RAM disk (initramfs) along with the appropriate device tree blob into memory.
  6. Kernel Initialization: The Linux kernel takes control from GRUB. It initializes the rest of the system hardware based on the device tree passed by the bootloader, and starts the init process (PID 1, typically systemd on RHEL) from the initramfs. The initramfs contains enough kernel modules for systemd to load the drivers for the various storage devices and find and mount the root filesystem. It pivots the mount points to relocate the rootfs on / and re-executes itself from the version present in /. This then leads to the full RHEL user environment and login prompt.

The SiFive HiFive Premier P550 supports booting from SPI flash as described. Once U-Boot on SPI flash is running, it can boot the next stage (kernel and userspace) from other storage media. While U-Boot can search for an extlinux.conf file for booting, the RHEL 10 Developer Preview image utilizes U-Boot's EFI capabilities to load GRUB.

Comments