Getting Started with RHEL 10 on SiFive HiFive Premier P550

This guide provides instructions and information for installing Red Hat Enterprise Linux (RHEL) 10 Developer Preview on the SiFive HiFive Premier P550 development board.

About the Hardware and Software

The SiFive HiFive Premier P550 (also referred to as "HF106") is a RISC-V 64-bit development system. It consists of a system on module (SOM - HF106S) and a carrier (HF106C) board. It features open firmware (such as U-Boot and OpenSBI), a baseboard management controller (BMC), multiple network interfaces, JTAG, and various other peripherals.

Red Hat has partnered with SiFive to offer a developer preview of RHEL 10 on this platform. This 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.

Installation

Choosing a Storage Option

The SiFive HiFive Premier P550 board offers various options when it comes to storage. You should pick the one that best suits your use case.

• SATA drive: This is probably the best all-around option, since it allows very good performance while leaving the PCIe slot available so that a GPU can be installed in it.
• NVMe drive: Unlocks the fastest storage performance, but prevents a GPU from being installed. Good choice for headless systems such as build servers. Requires additional hardware (NVMe PCIe adapter) to be purchased.
• 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: Using a microSD card is not recommended due to observed reliability issues when booting RHEL 10 off this device. Should only be used for testing or as a way to get the OS image flashed to a better storage device.

What You Will Need

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

• SATA drive and SATA cable
  • Recommended for installation: SATA USB enclosure or adapter
• NVMe drive and NVMe PCIe adapter
  • Recommended for installation: NVMe USB enclosure or adapter
• USB drive
• microSD card
  • As a reminder, using a microSD card is strongly discouraged.
  • 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:

• USB-C to USB-A cable for serial console access (included in the box)
• ATX power supply (see the official compatibility list)

Optionally, you might also want to acquire the following:

• PCIe graphics card (GPU)
• Monitor
• USB keyboard
• USB mouse

You only need a GPU, monitor, keyboard and mouse if you are interested in using the graphical interface. The board's built-in GPU is not enabled in RHEL 10. See Appendix B: Known Working GPUs for a list of GPUs that have been confirmed to work.

Preparing the Storage Device

RHEL 10 Developer Preview for the SiFive HiFive Premier P550 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 Developer Preview for RISC-V page on the 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.0-riscv64-dev-preview.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.0-riscv64-dev-preview.img of=/dev/sdX. Replace /path/to/rhel-10.0-riscv64-dev-preview.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.0-riscv64-dev-preview.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.

The HiFive Premier P550 Image Update Procedure document mentions that balena Etcher might show a "Missing partition table" warning when flashing non-bootable utility images, advising to click "Continue". This warning may or may not appear for a bootable OS image like the RHEL 10 for RISC-V Developer Preview.

Alternative Installation Methods

The process documented above is just one of the many possibilities when it comes to preparing the storage device: ultimately, anything that results in the image being written accurately will work just fine.

For example, Chapter 2 of the HiFive Premier P550 Image Update Procedure document describes how to write the Ubuntu image to the board's eMMC chip directly from the U-Boot prompt. A very similar process can be used to write the RHEL 10 image to a SATA drive that's already connected to the board: simply run

=> es_fs write usb 0 rhel-10.0-riscv64-dev-preview.img sata 0

Another possibility is to transfer the image to an OS that's already installed on the board and write it from there: for example, if you have Yocto or any other OS (including RHEL 10 itself) running off a USB drive, you can write the RHEL 10 image to the NVMe drive by running

$ sudo dd iflag=fullblock oflag=direct bs=4M status=progress conv=fsync if=/path/to/rhel-10.0-riscv64-dev-preview.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.

Board Setup

Connecting the Storage Device

Depending on your choice of storage, the steps are going to be different.

• For SATA: Connect the SATA data cable to the SATA connector (#33 in Figure 1-1 of the SiFive HiFive Premier P550 Getting Started Guide) and connect power to the SATA drive.
• For NVMe: This requires an M.2 adapter card that plugs into the PCIe slot (#27 in Figure 1-1 of the P550 Getting Started Guide, which is a 4-lane PCIe Gen 3 connector with an x16 mechanical form factor). Install the NVMe drive into the adapter card, then plug the adapter card into the PCIe slot.
• For USB: Plug the USB drive into the USB port on the back of the board. Make sure to use the USB port on the bottom, since boot might not work when using the one on the top.
• For microSD card: Insert the microSD card into the microSD slot on the back of the board.

Please ensure that only one storage device is connected to the board at any given time. When multiple storage devices are connected, it is possible that the wrong one will be picked. Avoid this situation by disconnecting all storage devices except the one you want to boot from.

Checking the Boot DIP Switches

Ensure the Boot Select DIP switch (SW1, #28 in Figure 1-1 of the P550 Getting Started Guide) is set to allow booting from U-Boot on SPI-Flash (default setting "0010"). U-Boot will then scan for bootable media, with the microSD card (MMC1) being the first in its search order for an operating system.

Connecting Peripherals

Connect a keyboard and mouse via the USB Type-A ports (#10 in Figure 1-1 of the P550 Getting Started Guide) if you intend to use a graphical interface (requires a separate PCIe graphics card as onboard HDMI is not enabled in the initial release).

Connect a display to your PCIe graphics card if used.

Crucially, connect the serial console as described in the next section. This is essential for the first boot and initial setup.

Connecting To the Board's Serial Console

Use a USB-C cable to connect the USB-C port on the back of the SiFive HiFive Premier P550 board (Port 15 in Figure 1-1 of the P550 Getting Started Guide) to your computer. This port connects to an FTDI FT4232 USB-to-UART controller.

The FTDI controller enumerates four serial ports, which on Linux show up as such:

/dev/serial/by-id
├── usb-FTDI_Quad_RS232-HS-if00-port0 (SoC JTAG)
├── usb-FTDI_Quad_RS232-HS-if01-port0 (BMC/MCU JTAG)
├── usb-FTDI_Quad_RS232-HS-if02-port0 (System Serial Console / SoC UART0)
└── usb-FTDI_Quad_RS232-HS-if03-port0 (BMC/MCU UART Console)

Refer to HiFive Premier P550 Software Reference Manual, Table 4 and SiFive HiFive Premier P550 Getting Started Guide, section 7.2 for more details.

Depending on the OS, the device that you will need to use to access the system serial console (SoC UART0) will be different.

On Linux:

These are often named /dev/ttyUSB0 through /dev/ttyUSB3. For more stable identification, use the paths under /dev/serial/by-id/, as displayed above. The correct device is typically going to be /dev/serial/by-id/usb-FTDI_Quad_RS232-HS-if02-port0.

On Windows:

They will appear as COM ports (e.g., COM7, COM8, COM9, COM10). The system serial console is typically the third COM port assigned to the FTDI device group.

Once you've identified the 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

Refer to section 7.2 of the SiFive HiFive Premier P550 Getting Started Guide for detailed setup.

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 SiFive HiFive Premier P550, you need to ensure that you're running the latest version of the firmware. At the time of this writing, that would be version 2025.04.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.

In addition to the steps mentioned in the guide, after upgrading the firmware and before rebooting the board you should also run the following commands at the U-Boot prompt:

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

This will restore U-Boot's configuration to its default, known good state.

You may also wish to run the following commands to limit U-Boot output to only the serial console to make the GRUB menu more responsive:

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

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, 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 for the SiFive HiFive Premier P550 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 manger, 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/42/Container/riscv64/images/Fedora-Container-Base-Generic-42.20250414-8635a3a5bfcd.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:42

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.
• 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:

• Intermittent failure to boot: the machine will sometimes fail to boot properly. This is usually caused by a critical component of the system running into a fatal "unhandled signal" error. This issue shows up with significant frequency when booting off microSD card, which is why Red Hat recommends to avoid that type of storage device in favor of SATA, NVMe or USB.
• Intermittent failure to shut down/reboot: The system sometimes hangs before U-Boot fully re-initializes. When that happens, use the board's reset or power button.
• 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".

Community and Support

• SiFive Forums: For questions and support: HiFive Premier P550 - SiFive Community.
• HiFive Premier P550 Page: For supplemental information and documentation: SiFive HiFive Premier P550 Board.

Document References

• HiFive Premier P550 Getting Started Guide
• HiFive Premier P550 Software Reference Manual
• HiFive Premier P550 Image Update Procedure
• HiFive Premier P550 MCU User Manual
• PSU Compatibility List

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 SiFive HiFive Premier P550. 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.