How To Install Fwupd on openSUSE

Firmware updates play a crucial role in maintaining the security and optimal performance of your hardware devices. As technological threats evolve, keeping your firmware updated has become as important as updating your operating system. Fwupd is a powerful daemon designed specifically for Linux systems that simplifies the process of updating firmware for various devices. This article provides a comprehensive guide on installing and configuring fwupd on openSUSE, one of the leading Linux distributions known for its stability and enterprise-grade features.

Whether you’re using openSUSE Tumbleweed, Leap, or Factory, this guide will walk you through the installation process step by step. You’ll also learn about the Linux Vendor Firmware Service (LVFS), essential configuration settings, and best practices for managing firmware updates. By the end, you’ll have a robust firmware update system that keeps your hardware secure and functioning optimally.

Understanding Fwupd and LVFS

Fwupd is not just another system utility—it’s a specialized daemon developed to streamline the firmware update process across Linux distributions. The primary purpose of fwupd is to create a standardized mechanism that allows session software to seamlessly update device firmware on your local machine. While designed initially for desktop environments, fwupd’s versatility makes it equally effective on phones and headless servers.

The Linux Vendor Firmware Service (LVFS) works hand-in-hand with fwupd to create a robust firmware update ecosystem. LVFS functions as a secure web service where hardware manufacturers can upload firmware updates for their devices. This centralized approach eliminates the need for users to visit multiple vendor websites to find and download updates. The service hosts firmware files and provides essential metadata that client applications like fwupd can use to identify and apply updates correctly.

The relationship between fwupd and major Linux distributions is symbiotic. Distributions like openSUSE integrate fwupd into their package repositories, making it readily available to users. Meanwhile, the metadata and files from LVFS are utilized by these distributions to provide up-to-date firmware information.

Fwupd can handle updates for a wide range of devices, including but not limited to:

• UEFI/BIOS firmware
• SSD and HDD firmware
• Network interface cards
• Graphics cards
• Input devices like mice and keyboards
• Printers and scanners
• Thunderbolt and USB-C controllers

The security benefits of this standardized approach are significant. By using cryptographically signed firmware packages, fwupd ensures that only authentic updates from verified sources are installed on your system. This prevents potentially malicious firmware from compromising your hardware.

Prerequisites for Installing Fwupd

Before proceeding with the installation of fwupd on your openSUSE system, ensure that your environment meets all necessary requirements for a smooth installation and operation. Taking these preparatory steps will help avoid common issues and ensure optimal performance.

First, check your openSUSE version to determine the appropriate installation method. Different versions of openSUSE (Tumbleweed, Leap, or Factory) have slightly different installation processes. You can verify your version by running the command cat /etc/os-release in your terminal.

Next, verify if fwupd is already installed on your system. Some newer openSUSE installations might come with fwupd pre-installed. Run rpm -q fwupd to check. If the command returns a package name and version, fwupd is already installed on your system.

Regarding permissions, ensure you have root or sudo access to your system. Installing system packages and managing firmware requires elevated privileges. Without these permissions, you won’t be able to complete the installation or perform firmware updates.

A stable internet connection is essential since you’ll need to download packages from openSUSE repositories and firmware metadata from LVFS servers. For optimal performance, a broadband connection is recommended, especially when downloading larger firmware updates.

Hardware compatibility is another crucial factor. While fwupd supports a wide range of devices, not all hardware is compatible with the system. You can check the compatibility of your devices on the LVFS website or by using the fwupdmgr get-devices command after installation.

Finally, ensure that your system is up-to-date before installing fwupd. Run sudo zypper update to update all packages on your system. This helps prevent potential compatibility issues with newer packages.

Installation Methods for openSUSE Tumbleweed

OpenSUSE Tumbleweed is a rolling-release distribution that provides the latest stable versions of software. Installing fwupd on Tumbleweed involves a straightforward process using the package manager. Let’s go through the steps in detail.

First, open your terminal application. You’ll need to add the Base:System repository, which contains the fwupd package. Execute the following command with root privileges:

sudo zypper addrepo https://download.opensuse.org/repositories/Base:System/openSUSE_Tumbleweed/Base:System.repo

This command adds the Base:System repository configuration to your system’s package manager. The repository contains system packages including fwupd and its dependencies.

Next, refresh your repository metadata to ensure your system has the latest information about available packages. This step is crucial for retrieving the correct version of fwupd:

sudo zypper refresh

After refreshing the repositories, install fwupd with the following command:

sudo zypper install fwupd

The package manager will resolve dependencies and download the required packages. When prompted, confirm the installation by typing ‘y’ and pressing Enter.

To verify that fwupd was installed successfully, check the installed version:

fwupdmgr --version

You should see the version number displayed in your terminal. If you encounter any errors at this stage, they’re usually related to repository access or dependency issues.

If you receive a “command not found” error, ensure that the installation path is in your system’s PATH variable. The fwupd executables are typically installed in /usr/bin/, which should be in your PATH by default.

For dependency issues, you can try reinstalling with the --fix-broken option:

sudo zypper install --fix-broken fwupd

Once installed successfully, the fwupd service should be automatically enabled. You can verify its status with:

systemctl status fwupd.service

The output should indicate that the service is active and running. If not, you can start it manually:

sudo systemctl start fwupd.service

Installation on openSUSE Leap

OpenSUSE Leap differs from Tumbleweed as it’s a regular-release distribution focusing on stability rather than providing the latest software versions. The installation process for fwupd on Leap is similar to Tumbleweed but requires different repository sources.

For openSUSE Leap 15.5 and other supported versions, begin by adding the appropriate repository. Open your terminal and execute the following command:

sudo zypper addrepo https://download.opensuse.org/repositories/Base:System/openSUSE_Leap_15.5/Base:System.repo

Replace “15.5” with your specific version of Leap if different. This adds the Base:System repository configured for your Leap version.

After adding the repository, refresh your package database:

sudo zypper refresh

Now install fwupd by running:

sudo zypper install fwupd

Alternatively, if you prefer using patches, you can install the recommended update for fwupd using the specific patch command for your version. For Leap 15.5, you would use:

sudo zypper in -t patch openSUSE-SLE-15.5-2023-4094=1

This command applies the specific patch referenced in the SUSE announcement for fwupd updates.

To verify your installation, use:

rpm -q fwupd

This should return the package name and version if the installation was successful.

If you encounter issues with the installation, check if there are any conflicts with existing packages:

sudo zypper verify fwupd

For openSUSE Leap installations that use the Desktop Applications Module, you might need to enable that module first:

sudo SUSEConnect -p sle-module-desktop-applications/15.5/x86_64

Once installed, start and enable the fwupd service:

sudo systemctl start fwupd.service
sudo systemctl enable fwupd.service

Installation on openSUSE Factory

OpenSUSE Factory is the development version of openSUSE that eventually becomes Tumbleweed. Installing fwupd on Factory requires specific commands tailored to this development distribution.

First, add the Factory-specific repository by executing:

sudo zypper addrepo https://download.opensuse.org/repositories/Base:System/openSUSE_Factory/Base:System.repo

This command adds the Base:System repository configured specifically for openSUSE Factory.

Refresh your repository metadata to ensure you have the latest package information:

sudo zypper refresh

Next, install fwupd using:

sudo zypper install fwupd

When prompted, review the list of packages to be installed and confirm by typing ‘y’ and pressing Enter.

After installation, verify that fwupd is properly installed:

which fwupdmgr

This command should return the path to the fwupdmgr executable, typically /usr/bin/fwupdmgr.

For development versions like Factory, it’s important to check for any known issues or bugs that might affect fwupd functionality. You can review the package’s issue tracker or community forums for any reported problems with the current Factory version.

Additionally, since Factory is a development version, you might want to enable debug logging for fwupd to help identify any issues:

sudo mkdir -p /etc/fwupd
echo "VerboseDomains=*" | sudo tee -a /etc/fwupd/daemon.conf

This configuration enables verbose logging for all domains, which can be helpful when troubleshooting in a development environment.

Alternative Installation Methods

While the standard repository method is recommended for most users, alternative approaches offer flexibility in specific scenarios. Understanding these options helps you choose the most suitable installation method for your needs.

Snap Packages

Snap is a universal package format that works across many Linux distributions. To install fwupd using Snap, you first need to ensure that snapd is installed:

sudo zypper install snapd
sudo systemctl enable --now snapd

After installing snapd, you can install fwupd using:

sudo snap install fwupd

The Snap version of fwupd runs in a confined environment, which might limit its access to system resources. However, it offers automatic updates and is maintained by the fwupd developers.

Flatpak Installation

Flatpak is another universal package format that focuses on sandboxed applications. To use Flatpak, first install the Flatpak system:

sudo zypper install flatpak

Then add the Flathub repository:

flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

Install the GNOME Firmware application, which includes fwupd functionality:

flatpak install flathub org.gnome.Firmware

The Flatpak version provides a graphical interface for managing firmware updates but might have limited system integration compared to the native package.

Configuring Fwupd After Installation

After successfully installing fwupd, proper configuration ensures optimal performance and security. The configuration process involves understanding where configuration files are located, setting up essential options, and managing the service.

The main configuration files for fwupd are located in the /etc/fwupd/ directory. The primary configuration file is daemon.conf, which controls the behavior of the fwupd daemon. Additionally, you’ll find uefi.conf for UEFI-specific settings and remotes.d/ directory containing configuration files for firmware sources.

To create a basic configuration, if one doesn’t already exist:

sudo mkdir -p /etc/fwupd
sudo touch /etc/fwupd/daemon.conf

Open the daemon.conf file in your preferred text editor:

sudo nano /etc/fwupd/daemon.conf

Essential configuration options include:

[fwupd]
DisabledDevices=
DisabledPlugins=
EnabledPlugins=
VerboseDomains=

You can disable specific devices by adding their device IDs to the DisabledDevices line, separated by semicolons. Similarly, you can disable or enable specific plugins using the respective options.

For automatic updates, you’ll need to enable and configure the system timer. First, enable the timer service:

sudo systemctl enable fwupd-refresh.timer

To customize the update schedule, create an override file:

sudo mkdir -p /etc/systemd/system/fwupd-refresh.timer.d/
echo "[Timer]" | sudo tee /etc/systemd/system/fwupd-refresh.timer.d/override.conf
echo "OnCalendar=Mon *-*-* 06:00:00" | sudo tee -a /etc/systemd/system/fwupd-refresh.timer.d/override.conf

This example sets automatic metadata refresh to occur every Monday at 6 AM. Adjust the schedule according to your preferences.

To manage the fwupd service using systemd, use these common commands:

• Check status: systemctl status fwupd.service
• Start the service: sudo systemctl start fwupd.service
• Stop the service: sudo systemctl stop fwupd.service
• Restart the service: sudo systemctl restart fwupd.service
• Enable at boot: sudo systemctl enable fwupd.service

For hardware-specific configurations, you might need to add rules to allow fwupd to access certain devices. These rules are typically stored in /etc/udev/rules.d/ and are provided by the fwupd package by default.

Setting Up UEFI Firmware Updates

UEFI firmware updates require additional setup beyond the basic fwupd installation. This ensures that the system can safely update UEFI firmware while maintaining system integrity and bootability.

First, verify that your system is using UEFI boot mode:

[ -d /sys/firmware/efi ] && echo "UEFI boot mode" || echo "Legacy boot mode"

If your system is in UEFI mode, you’ll need to configure access to the EFI System Partition (ESP). The ESP is where UEFI firmware updates are staged before being applied during system boot.

Identify your ESP partition:

sudo parted -l | grep "EFI System"

The output will show the disk and partition number of your ESP. Typically, it’s the first partition on the disk and around 100-500MB in size.

To create the proper directory structure for fwupd, you’ll need to mount the ESP. First, check if it’s already mounted:

mount | grep esp

If not mounted, create a mount point and mount it:

sudo mkdir -p /boot/efi
sudo mount /dev/sdXY /boot/efi

Replace /dev/sdXY with your actual ESP partition (e.g., /dev/sda1).

For permanent mounting, add an entry to your /etc/fstab file:

sudo echo "UUID=$(blkid -s UUID -o value /dev/sdXY) /boot/efi vfat umask=0077,shortname=winnt 0 2" | sudo tee -a /etc/fstab

Next, create the directory structure needed by fwupd:

sudo mkdir -p /boot/efi/EFI/org.freedesktop.fwupd

Verify that fwupd can access the ESP:

sudo fwupdmgr get-devices

Look for entries related to your system firmware or UEFI BIOS. If found, fwupd can detect your firmware and is ready to handle updates.

For dual-boot systems, ensure that the ESP is large enough (at least 500MB recommended) to accommodate firmware updates alongside existing boot loaders. If needed, you can resize the ESP using tools like GParted from a live USB environment.

Some systems require specific UEFI settings to allow firmware updates. Access your UEFI/BIOS setup and ensure that:

• Secure Boot is configured correctly (see the next section)
• UEFI firmware updates are allowed
• Any BIOS protection features are temporarily disabled during updates

Secure Boot Configuration

Secure Boot is a security feature in modern UEFI firmware that ensures only signed bootloaders and kernels can be executed during the boot process. Configuring fwupd to work with Secure Boot requires additional steps to maintain this security while enabling firmware updates.

First, check if Secure Boot is enabled on your system:

bootctl status | grep "Secure Boot"

If Secure Boot is active, you’ll need to ensure that fwupd can authenticate firmware packages. openSUSE uses shim, a small bootloader signed by Microsoft, to establish a chain of trust.

To check if shim is installed:

rpm -q shim

If not installed, install it:

sudo zypper install shim

For fwupd to work with Secure Boot, it needs access to the system’s Machine Owner Key (MOK). These keys are used to verify the authenticity of firmware updates. You can view the current MOK certificates:

sudo mokutil --list-enrolled

If you need to generate your own signing keys for firmware validation:

sudo fwupdtool generate-cert --save=fwupd

This creates a new certificate and private key in /etc/pki/fwupd/.

To enroll this certificate in your system’s MOK:

sudo mokutil --import /etc/pki/fwupd/LVFS-CA.pem

You’ll be prompted to create a one-time password. Remember this password, as you’ll need it during the next system restart.

After rebooting, the MOK management screen will appear, allowing you to enroll the new key using the password you created.

Configuration file adjustments may also be necessary. Edit the UEFI configuration file:

sudo nano /etc/fwupd/uefi.conf

Ensure these settings are present for Secure Boot environments:

[uefi]
EnableSecureBoot=true
SecureBootPkcs7=@sysconfdir@/pki/fwupd/LVFS-CA.pem

The security implications of these configurations are significant. By properly configuring Secure Boot with fwupd, you maintain a secure boot chain while enabling firmware updates from trusted sources. This prevents unsigned or malicious firmware from being installed on your system.

Basic Fwupd Commands and Usage

After installing and configuring fwupd, learning the essential commands will help you manage firmware updates effectively. The command-line tool fwupdmgr provides a comprehensive interface for interacting with the fwupd daemon.

To list all devices that fwupd can detect on your system:

fwupdmgr get-devices

This command displays detailed information about each device, including the device name, ID, firmware version, and update status. Pay attention to the “Flags” field, which indicates whether the device can be updated.

To refresh the metadata from the Linux Vendor Firmware Service (LVFS):

fwupdmgr refresh

This command downloads the latest information about available firmware updates and supported devices. It’s recommended to run this command periodically or enable the automatic refresh timer.

To check for available updates for all detected devices:

fwupdmgr get-updates

If updates are available, this command lists the devices that can be updated, along with the current and available firmware versions.

To install available updates:

fwupdmgr update

This command downloads and installs firmware updates for all devices with available updates. Some updates may require a system restart to complete.

For updates that require special handling, you can specify additional options:

fwupdmgr update --allow-older    # Allow downgrading firmware
fwupdmgr update --allow-reinstall # Allow reinstalling the same version
fwupdmgr update --force          # Force update even if risky

Understanding the difference between immediate and staged updates is crucial. Immediate updates are applied directly and take effect immediately, while staged updates are prepared during runtime but only applied during the next system boot. This staging is essential for critical components like UEFI/BIOS updates, which cannot be safely updated while the system is running.

To view the update history:

fwupdmgr get-history

This displays a list of all firmware updates that have been applied on the system, including the device name, old and new versions, and the date of the update.

For focused operations on a specific device, you can use its device ID:

fwupdmgr get-updates [DEVICE_ID]
fwupdmgr update [DEVICE_ID]

Replace [DEVICE_ID] with the actual ID from the get-devices command output.

Advanced Configuration Options

For system administrators and power users, fwupd offers advanced configuration options to tailor the firmware update experience to specific requirements. These settings allow for fine-tuning of the daemon’s behavior and integration with enterprise environments.

Disabling the Local Cache Server (Passim)

Fwupd uses a local caching daemon called Passim to improve download performance. To disable this feature:

echo "[fwupd]" | sudo tee -a /etc/fwupd/daemon.conf
echo "UseLocalCacheServer=false" | sudo tee -a /etc/fwupd/daemon.conf

This configuration forces fwupd to download firmware directly from remote servers rather than using the local cache.

P2P Firmware Sharing Configuration

For networks with multiple machines, enabling P2P sharing can reduce bandwidth usage:

echo "[fwupd]" | sudo tee -a /etc/fwupd/daemon.conf
echo "P2PDownloading=true" | sudo tee -a /etc/fwupd/daemon.conf

With this setting, machines on the same network can share downloaded firmware files, reducing the need for multiple downloads from external servers.

Enterprise Firmware Filtering

In enterprise environments, controlling which firmware updates are applied is crucial:

mkdir -p /etc/fwupd/remotes.d
echo "[fwupd Remote]" | sudo tee /etc/fwupd/remotes.d/lvfs.conf
echo "Enabled=true" | sudo tee -a /etc/fwupd/remotes.d/lvfs.conf
echo "ApprovalRequired=true" | sudo tee -a /etc/fwupd/remotes.d/lvfs.conf

With ApprovalRequired set to true, updates will only be visible if they’ve been explicitly approved.

Approved Firmware Updates

To specify which updates are approved:

sudo mkdir -p /etc/fwupd/remotes.d/lvfs-approved

Create a file for each approved update in this directory, using the format [component_id].approved. For example:

echo "Approved=true" | sudo tee /etc/fwupd/remotes.d/lvfs-approved/com.example.device.firmware.approved

Remote Server Customization

To use a custom firmware server instead of the standard LVFS:

echo "[fwupd Remote]" | sudo tee /etc/fwupd/remotes.d/custom.conf
echo "Enabled=true" | sudo tee -a /etc/fwupd/remotes.d/custom.conf
echo "MetadataURI=https://firmware.example.com/metadata.xml.gz" | sudo tee -a /etc/fwupd/remotes.d/custom.conf
echo "FirmwareBaseURI=https://firmware.example.com/firmware/" | sudo tee -a /etc/fwupd/remotes.d/custom.conf

Replace the URIs with your actual server addresses. This configuration is particularly useful for air-gapped networks or organizations that maintain their own firmware repositories.

After making any configuration changes, restart the fwupd service to apply them:

sudo systemctl restart fwupd.service

These advanced options provide flexibility for integrating fwupd into various environments, from single workstations to large enterprise deployments. By understanding and applying these configurations, you can ensure that firmware updates align with your specific requirements and security policies.

Troubleshooting Common Issues

Even with careful installation and configuration, you might encounter issues with fwupd. This section addresses common problems and provides practical solutions to resolve them.

Handling Read-Only Filesystem Errors

If you encounter errors about a read-only filesystem when updating firmware:

Error: failed to create directory /boot/efi/EFI/org.freedesktop.fwupd: Read-only file system

First, check if the ESP is mounted with write permissions:

mount | grep efi

If it’s mounted as read-only (ro), remount it with write permissions:

sudo mount -o remount,rw /boot/efi

For permanent fixing, ensure your /etc/fstab entry doesn’t include the “ro” option for the ESP.

Resolving ESP Detection Problems

If fwupd fails to detect the ESP:

Error: failed to find ESP: No ESP found

Verify that your ESP is properly marked with the correct partition type:

sudo parted -l | grep "EFI"

If not correctly marked, you might need to set the proper partition flag:

sudo parted /dev/sdX
(parted) set Y esp on
(parted) quit

Replace X with your disk letter and Y with the ESP partition number.

Addressing Stuck Reboots During Updates

If your system gets stuck during reboot after a firmware update:

1. Try performing a hard reset (hold the power button)
2. Boot into recovery mode if available
3. Check firmware update logs: sudo journalctl -u fwupd
4. If the update failed, try reinstalling with: sudo fwupdmgr install --force [FILE]

In some cases, you might need to restore backup firmware using manufacturer-specific recovery methods.

Fixing MSR Plugin Failures

If you see errors related to the MSR (Model-Specific Register) plugin:

Error: failed to open /dev/cpu/0/msr: Permission denied

Ensure the msr module is loaded:

sudo modprobe msr

Add it to automatically load at boot:

echo "msr" | sudo tee -a /etc/modules-load.d/msr.conf

Solving “No ESP with path” Errors

For errors like:

Error: failed to detect ESP: No ESP with path '/boot/efi' detected

Verify that the EFI partition is correctly mounted:

sudo mkdir -p /boot/efi
sudo mount -t vfat /dev/sdXY /boot/efi

Add the correct entry to /etc/fstab for persistence.

Steps When Updates Don’t Apply After Reboot

If updates don’t apply after a system reboot:

1. Check the update status: fwupdmgr get-updates
2. Review system logs: journalctl -u fwupd
3. Verify that the ESP is accessible and properly mounted
4. Try manually reinstalling the update: sudo fwupdmgr update --force
5. Check if Secure Boot or other firmware protection is blocking the update

For service startup failures as mentioned in the search results, verify that all dependencies are installed correctly:

sudo zypper verify fwupd

If you see symbol lookup errors like “undefined symbol: libusb_get_parent”, try reinstalling the dependencies:

sudo zypper install --force libgusb libusb

Remember that detailed error logs can be found in the system journal:

sudo journalctl -u fwupd.service

These logs often contain specific error messages that can help identify the root cause of problems.

Security Best Practices

Firmware updates directly affect your hardware’s operation, making security considerations paramount. Following these best practices ensures that updates are applied safely and securely.

Firmware verification is the cornerstone of secure updates. Always ensure that firmware packages are signed and verified before installation. Fwupd performs this verification automatically, but you can explicitly check a firmware file’s signature:

fwupdtool verify firmware.cab

Creating system backups before applying firmware updates provides a safety net in case things go wrong. While firmware backups aren’t always possible, you should at least back up your important data:

sudo cp -r /boot/efi /boot/efi.backup

For critical systems, consider creating a full system image using tools like Clonezilla before major firmware updates.

Update reporting considerations balance security improvements with privacy. By default, fwupd reports successful updates back to LVFS, helping vendors track adoption rates and identify potential issues. If this raises privacy concerns, you can disable reporting:

mkdir -p ~/.config/fwupd
echo "ReportingEnabled=false" > ~/.config/fwupd/daemon.conf

For privacy aspects of firmware updates, be aware that some firmware might collect telemetry data. Research your device manufacturer’s privacy policies before updating. In enterprise environments, review firmware changes for compliance with your organization’s privacy requirements.

When handling sensitive hardware like security keys or specialized equipment, take extra precautions:

1. Research each update thoroughly before applying
2. Test updates on non-critical hardware first
3. Have recovery procedures in place
4. Consider whether the security benefits outweigh potential risks

Remember that some updates might change hardware behavior or power management, which could have security implications beyond the firmware itself. Always review the update changelog and understand what changes are being made.

Firmware Update Reporting

Reporting firmware update status back to the Linux Vendor Firmware Service (LVFS) contributes valuable data to the broader Linux community while helping vendors improve their firmware quality.

The primary tool for reporting update history is the fwupdmgr report-history command. When executed, this command:

1. Collects information about successful and failed firmware updates
2. Anonymizes the data to protect your privacy
3. Submits the report to the LVFS server

To use this feature:

fwupdmgr report-history

The benefits of reporting for the ecosystem are substantial. When users report update outcomes, vendors gain insights into:

• Success rates for different firmware versions
• Common failure modes and their frequencies
• Hardware configurations that might need special attention
• Geographic distribution of firmware versions

This information helps vendors prioritize fixes and improvements, ultimately leading to more reliable firmware for all users.

Before reporting, review the privacy policy considerations. LVFS collects only technical data related to the update process, including:

• Device hardware IDs
• Firmware versions (before and after update)
• Success or failure status
• Non-identifying system information

Personal information like usernames, IP addresses, or location data is not included in the reports. However, if you’re concerned about privacy, you can review exactly what will be sent before submission:

fwupdmgr report-history --show

This displays the JSON data that would be submitted, allowing you to make an informed decision.

Contributing to firmware update improvement benefits the entire Linux community. By participating in this feedback loop, you help create a more robust and reliable firmware ecosystem for all users.

Congratulations! You have successfully installed Fwupd. Thanks for using this tutorial for installing Fwupd on openSUSE Linux system. For additional help or useful information, we recommend you check the official Fwupd website.