# Get started with the Qualcomm Linux kernel

This information explains how to download, configure, and develop the Qualcomm^®^ Linux kernel for the Qualcomm Linux development kit and its associated
components to build and flash system images.

Before you begin downloading and configuring the Qualcomm Linux kernel, set up your host computer as described in the [Qualcomm
Linux Build Guide](doc/80-80022-254), which
also provides information about the common Qualcomm Linux kernel workflows.

## Access Qualcomm Linux kernel source code

To access the source code for the full Qualcomm^®^ Linux^®^ BSP, see the
[Qualcomm Linux Build Guide](doc/80-80022-254)
and get all the necessary Qualcomm Linux meta layers. Follow corresponding
build instructions that fetch all source code including kernel.

Clone the repository to access the Linux kernel code directly. The
Linux kernel repository is hosted at [kernel/qcom-6.18.y](https://github.com/qualcomm-linux/kernel/tree/qcom-6.18.y).

For more information, see [recipes-kernel/linux/linux-qcom_6.18.bb](https://github.com/qualcomm-linux/meta-qcom/blob/master/recipes-kernel/linux/linux-qcom_6.18.bb).

Qualcomm Linux supports a mainline kernel that moves along with upstream kernel
tip and the LTS Linux kernel (6.18.y) as part of [meta-qcom](https://github.com/qualcomm-linux/meta-qcom/) layer.

> 
> 
> - Mainline Linux kernel is supported by recipe [recipes-kernel/linux/linux-qcom-next_git.bb](https://github.com/qualcomm-linux/meta-qcom/blob/master/recipes-kernel/linux/linux-qcom-next_git.bb).
> - LTS Linux Kernel is supported by recipe [recipes-kernel/linux/linux-qcom_6.18.bb](https://github.com/qualcomm-linux/meta-qcom/blob/master/recipes-kernel/linux/linux-qcom_6.18.bb).

See the corresponding recipe to know the Git uniform resource identifier (URI)
to download the kernel source code.

For more information about Qualcomm Linux layers, see [Qualcomm Linux metadata layers](https://docs.qualcomm.com/bundle/publicresource/topics/80-80022-27/qualcomm_linux_metadata_layers.html).

> 
> 
> Note
> 
> 
> Yocto recipe refers to Qualcomm Linux kernel sources that are publicly hosted at [GitHub](https://github.com/qualcomm-linux/kernel).

The following example shows the Qualcomm Linux kernel recipe source URI information for the LTS BSP:

SECTION = "kernel"
    
    SUMMARY = "Linux kernel for QCOM devices"
    DESCRIPTION = "Recipe to build Linux kernel from 6.18 LTS branch"
    LICENSE = "GPL-2.0-only"
    LIC_FILES_CHKSUM = "file://COPYING;md5=6bc538ed5bd9a7fc9398086aedcd7e46"
    
    inherit kernel
    
    COMPATIBLE_MACHINE = "(qcom)"
    LINUX_VERSION ?= "6.18"
    
    SRCREV ?= "b588875924316e2f73aa987cec342e624147f87c"
    SRCBRANCH:class-devupstream ?= "branch=qcom-6.18.y"
    
    SRC_URI = "git://github.com/qualcomm-linux/kernel.git;${SRCBRANCH};protocol=https"
    Copy to clipboard

## Identify supported Qualcomm machines

The Qualcomm machine configuration files are present in the
`meta-qcom/conf/machine/` directory.

Machine configuration files follow a `<SoC>-<board>-<variant>​.conf` naming convention, where:

- `SoC` is the system-on-chip (SoC) name
- `board` is the type of board for which the software is built
- `variant` is the type of product

For example:

In the `qcs6490-rb3gen2-core-kit.conf` filename,

- `qcs6490` is the SoC
- `rb3gen2` is the board
- `core-kit` is the type of product

The same naming convention is used in the platform-specific device tree files.

The following example shows the list of supported machines that are configured for Yocto:

- ls -l meta-qcom/conf/machine/[\*](https://docs.qualcomm.com/doc/80-80022-3/topic/getting_started_chapter2.html#id2).conf
- meta-qcom/conf/machine/iq-8275-evk.conf
- meta-qcom/conf/machine/iq-9075-evk.conf
- meta-qcom/conf/machine/qcs615-ride.conf
- meta-qcom/conf/machine/qcs6490-rb3gen2-core-kit.conf
- meta-qcom/conf/machine/qcs8300-ride-sx.conf
- meta-qcom/conf/machine/qcs9100-ride-sx.conf

The following example shows the machine configuration selection for the development board with Qualcomm chipset:

less meta-qcom/conf/machine/<SoC>-<board>-<variant>.conf
    
    #@TYPE: Machine
    #@NAME: <Machine name same as the machine conf file or ``<SoC>-<board>-<variant>`` >
    #@DESCRIPTION: Machine configuration for the development board, with Qualcomm qcs6490
    Copy to clipboard

The following example shows the kernel configuration selection for the LTS version:

less meta-qcom/conf/machine/include/qcom-base.inc
    
    # Provider for linux kernel
    PREFERRED_PROVIDER_virtual/kernel = "linux-qcom"
    PREFERRED_VERSION_virtual/kernel = "6.18%"
    Copy to clipboard

Note

- `linux-qcom` is selected for LTS BSP.
- `linux-qcom-next` is selected for mainline BSP and `PREFERRED_VERSION_virtual/kernel` is set empty.

## Build Yocto image recipes and kernel configuration

You can access the Qualcomm Linux image recipes to modify the kernel
configurations. The following table lists some of the main supported
`meta-qcom` images:

Table: Qualcomm Linux supported image recipes

| Image name | Description |
| --- | --- |
| qcom-console-image<br>    Copy to clipboard | This is a boot-to-shell image with the package group to bring in all basic packages. |
| qcom-multimedia-image<br>    Copy to clipboard | This image recipe includes recipes for multimedia software components, such as audio, Bluetooth^®^, camera, computer vision, display, and video. |

To build the images listed in [Table: Qualcomm Linux supported image recipes](https://docs.qualcomm.com/doc/80-80022-3/topic/getting_started_chapter2.html#qualcomm-linux-supported-image-recipes), the Qualcomm
Linux kernel BSP recipe uses one of the following kernel configuration
fragments:

Table: kernel configuration fragments

| Kernel configuration fragments | Description |
| --- | --- |
| <kernel_src>/arch/arm64/configs/defconfig<br>    Copy to clipboard | Uses upstream arm64 defconfig as the base configuration |
| <kernel_src>/arch/arm64/configs/prune.config<br>    Copy to clipboard | Prunes unwanted configurations from upstream defconfig to optimize build time |
| <kernel_src>/arch/arm64/configs/qcom.config<br>    Copy to clipboard | Enables `qcom` configuration that is not a part of upstream defconfig |
| <kernel_src>/kernel/configs/debug.config<br>    Copy to clipboard | Enables kernel standard debug configuration |
| <kernel_src>/kernel/configs/hardening.config<br>    Copy to clipboard | Enables security configurations to harden production kernel |
| <kernel_src>/arch/arm64/configs/rt.config<br>    Copy to clipboard | Enables `PREEMPT_RT` configurations for real-time kernel support |

For more information, see [Configure the kernel](https://docs.qualcomm.com/doc/80-80022-3/topic/kernel-development.html#configure-the-kernel).

To modify the build configurations, update `KBUILD_DEFCONFIG` and `KBUILD_CONFIG_EXTRA` variables
in the `recipes-kernel/linux/linux-qcom_6.18.bb` or `recipes-kernel/linux/linux-qcom-next_git.bb`
kernel recipe in the `meta-qcom` layer.

### Example kernel configuration

The following example shows the kernel configuration using `recipes-kernel/linux/linux-qcom_6.18.bb` kernel recipe:

KBUILD_DEFCONFIG ?= "defconfig"
    KBUILD_DEFCONFIG:qcom-armv7a = "qcom_defconfig"
    
    KBUILD_CONFIG_EXTRA = "${@bb.utils.contains('DISTRO_FEATURES', 'hardened', '${S}/kernel/configs/hardening.config', '', d)}"
    KBUILD_CONFIG_EXTRA:append:aarch64 = " ${S}/arch/arm64/configs/prune.config"
    KBUILD_CONFIG_EXTRA:append:aarch64 = " ${S}/arch/arm64/configs/qcom.config"
    KBUILD_CONFIG_EXTRA:append = " ${@oe.utils.vartrue('DEBUG_BUILD', '${S}/kernel/configs/debug.config', '', d)}"
    Copy to clipboard

Note

Yocto maintains an additional configuration fragment that applies on top to
manage distro level kernel configuration:
`meta-qcom/recipes-kernel/linux/linux-qcom-6.18/configs/bsp-additions.cfg`.

For more information about the build instructions, see [Build with QSC
CLI](https://docs.qualcomm.com/bundle/publicresource/topics/80-80022-254/build_frm_source_qsc_cli.html#build-from-source-qsc-cli) in the [Qualcomm Linux Build Guide](doc/80-80022-254).

## Access the platform device tree

The Qualcomm DTSI and device tree source
(DTS) files for supported development kits are present under the
kernel source in the `arch/arm64/boot/dts/qcom/` directory.

Device tree files marked with `el2` support Linux configurations
running at Exception Level 2 (EL2), such as KVM. The build system applies the `el2` overlays to the platform DTB to generate the corresponding EL2 DTB variants. Use these EL2‑specific DTBs only when Linux must operate as a KVM hypervisor.

The following example shows the DTB inclusion into the device configuration file:

KERNEL_DEVICETREE = " \
                         qcom/<SoC>-<board>-<variant>.dtb \
                         "
    Copy to clipboard

Tab QCS6490
Tab IQ-9075
Tab IQ-8275
Tab IQ-615

The following table lists the Qualcomm^®^ device tree files for the Dragonwing™ RB3 Gen 2 Development Kit.

> 
> 
> Table: Qualcomm device tree source
> 
> 
> | Device tree source | Details |
> | --- | --- |
> | arch/arm64/boot/dts/qcom/sc7280.dtsi<br>    Copy to clipboard | The QCS6490 SoC is derived from SC7280 SoC. |
> | arch/arm64/boot/dts/qcom/qcs6490-rb3gen2.dts<br>    Copy to clipboard | Device tree source for the QCS6490 Dragonwing™ RB3 Gen 2 Development Kit. |
> | arch/arm64/boot/dts/qcom/qcs6490-rb3gen2-vision-mezzanine.dts<br>    Copy to clipboard | QCS6490 Dragonwing™ RB3 Gen 2 vision Mezzanine Development Kit. |
> | arch/arm64/boot/dts/qcom/qcs6490-rb3gen2-industrial-mezzanine.dts<br>    Copy to clipboard | QCS6490 Dragonwing™ RB3 Gen 2 industrial Mezzanine Development Kit. |

The following table lists the Qualcomm device tree files for the Qualcomm Dragonwing™ IQ-9075 Development Kit.

> 
> 
> Table : Qualcomm device tree source
> 
> 
> | Device tree source | Details |
> | --- | --- |
> | arch/arm64/boot/dts/qcom/lemans.dtsi<br>    Copy to clipboard | The Dragonwing^TM^ IQ-9075 SoC is derived from Lemans. |
> | arch/arm64/boot/dts/qcom/lemans-el2.dtso<br>    Copy to clipboard | This overlay file is applied to all QCS9075 board variants to generate corresponding el2-specific device tree variants when Linux is running at Exception Level 2 (EL2), for example, in KVM environments. |
> | arch/arm64/boot/dts/qcom/lemans-ride-common.dtsi<br>    Copy to clipboard | Common dtsi for Qualcomm Linux development kit based on Lemans. |
> | arch/arm64/boot/dts/qcom/qcs9100-ride.dts and arch/arm64/boot/dts/qcom/qcs9100-ride-r3.dts<br>    Copy to clipboard | Qualcomm Linux development kit for Dragonwing^TM^ IQ-9100 ride. |
> | arch/arm64/boot/dts/qcom/lemans-evk.dts<br>    Copy to clipboard | Qualcomm Linux development kit for the Qualcomm Dragonwing^TM^ IQ-9075 EVK. |

The following table lists the Qualcomm device tree files for the Dragonwing^TM^ IQ-8275 Development Kit.
By default, the addons DTB is used.

> 
> 
> Table : Qualcomm device tree source
> 
> 
> | Device tree source | Details |
> | --- | --- |
> | arch/arm64/boot/dts/qcom/qcs8300.dtsi<br>    Copy to clipboard | The Dragonwing IQ-8275 SoC is derived from QCS8300 (Monaco). |
> | arch/arm64/boot/dts/qcom/qcs8300-ride.dts<br>    Copy to clipboard | Qualcomm Linux development kit for Dragonwing IQ-8300 ride. |
> | arch/arm64/boot/dts/qcom/monaco-evk.dtb<br>    Copy to clipboard | Qualcomm Linux development kit for the Dragonwing^TM^ IQ-8275 EVK. |

The following table lists the Qualcomm device tree files for the Dragonwing IQ-615 development kit.
By default, the addons DTB is used.

> 
> 
> Table : Qualcomm device tree source
> 
> 
> | Device tree source | Details |
> | --- | --- |
> | arch/arm64/boot/dts/qcom/qcs615.dtsi<br>    Copy to clipboard | The base configuration file for Dragonwing IQ-615 SoC. |
> | arch/arm64/boot/dts/qcom/qcs615-ride.dts<br>    Copy to clipboard | The base configuration file for Dragonwing IQ-615 ride. |

Note

In the v6.19 and later of upstream kernel, SoC DTSI names are updated to reflect the actual names.

- For example,
    - - sc7280.dtsi as `kodiak.dtsi`
- qcs8300.dtsi as `monaco.dtsi`
- qcs615.dtsi as `talos.dtsi`

## Manage out-of-tree kernel modules

Most of the kernel drivers are compiled from upstream kernel sources.
However, some drivers are maintained outside the kernel source tree and
are built as kernel modules using the Yocto build system.

In the following example, kernel graphics support layer (KGSL) GPU driver is an out-of-tree kernel module. The
recipe located at `recipes-graphics/kgsl-dlkm/kgsl-dlkm_git.bb`
compiles the driver as a kernel module. To autoload the kernel module
on boot, you can add the module name to the `KERNEL_MODULE_AUTOLOAD`
variable.

# Example out-of-tree Kernel module recipe
    inherit module
    
    DESCRIPTION = "Qualcomm KGSL driver for managing Adreno GPU"
    LICENSE = "GPL-2.0-only"
    LIC_FILES_CHKSUM = "file://adreno.c;beginline=1;endline=1;md5=fcab174c20ea2e2bc0be64b493708266"
    
    PV = "0.0+git"
    SRCREV = "553c972604f739564d6bb70e18e3857c041984b1"
    SRC_URI = " \
        git://github.com/qualcomm-linux/kgsl.git;branch=gfx-kernel.le.0.0;protocol=https \
        file://kgsl.rules \
    "
    
    do_install:append() {
          install -m 0644 ${WORKDIR}/sources/kgsl.rules -D ${D}${nonarch_base_libdir}/udev/rules.d/kgsl.rules
    }
    
    KERNEL_MODULE_PROBECONF += "msm_kgsl"
    module_conf_msm_kgsl = "blacklist msm_kgsl"
    
    FILES:${PN} += "${nonarch_base_libdir}/udev/rules.d"
    
    # The module is only intended to support ARMv8 machines
    COMPATIBLE_MACHINE = "^$"
    COMPATIBLE_MACHINE:aarch64 = "(.*)"
    Copy to clipboard

## Build the device image

Qualcomm Linux Yocto meta-qcom layer supports KAS to build images and maintains
KAS build configurations under `meta-qcom/ci/` directory. To build
the full image and kernel, run the following Yocto commands:

1. To install the KAS tool, run the following command:

> 
> 
> sudo pip3 install kas
>     Copy to clipboard

2. To clone `meta-qcom` layer, run the following command:

> 
> 
> git clone https://github.com/qualcomm-linux/meta-qcom.git -b master
>     Copy to clipboard

3. To build using the KAS configuration for one of the supported boards, run the following commands:

> 
> 
> kas build meta-qcom/ci/rb3gen2-core-kit.yml:meta-qcom/ci/linux-qcom-6.18.yml:meta-qcom/ci/qcom-distro.yml
>     Copy to clipboard

Run the following command to compile a debug build:

1. To ensure that you are in the KAS shell, run the following command:

> 
> 
> kas shell meta-qcom/ci/rb3gen2-core-kit.yml:meta-qcom/ci/linux-qcom-6.18.yml:meta-qcom/ci/qcom-distro.yml
>     Copy to clipboard

2. To compile the debug-enabled build, add `DEBUG_BUILD = "1"` to `build/conf/local.conf` or set the environment using the following command:

> 
> 
> DEBUG_BUILD=1 bitbake -c build qcom-multimedia-image
>     Copy to clipboard

The output build images that are ready to flash, are present in
`build/tmp/deploy/images/<Machine>/<Image>-*.rootfs.qcomflash` directory.
For example, for `rb3gen2-core-kit.yml`, it’s
`build/tmp/deploy/images/rb3gen2-core-kit/qcom-multimedia-image-*.rootfs.qcomflash/`.

## Bring up the device

After generating the Qualcomm Linux build, the system completes the kernel build and creates the kernel‑related images in the `build/tmp/deploy/images/<Machine>/<Image>-*.rootfs.qcomflash` directory.

The `efi.bin` in this directory corresponds to the ESP boot partition image and
contains the systemd-boot (boot manager), kernel, and initramfs images. This
image is flashed to the EFI system partition (ESP) to boot the device.

Device tree blobs are updated or added to the `KERNEL_DEVICETREE`
variable in the `conf/machine/<SoC>-<board>-<variant>.conf` file.
These device tree blobs are used to compile the dtbs and package them into a
`dtb.bin` image in same directory.

If you have not already flashed all boot binaries, follow the instructions in the [Qualcomm Linux Build Guide](doc/80-80022-254) to flash the board.

After that, you can incrementally flash the following binaries to boot the kernel or DTB.

Flash the `efi.bin` and `dtb.bin` images using the following fastboot commands:

# Bring the device in fastboot mode
    # cd to the source root location
    
    $ cd build/tmp/deploy/images/<Machine>/<Image>-*.rootfs.qcomflash/
    $ fastboot flash efi efi.bin
    $ fastboot flash dtb_a dtb.bin
    $ fastboot reboot
    Copy to clipboard

The following table lists the different kernel build artifacts:

Table : Kernel build artifacts

| Image | Image name | Build deploy path | Details |
| --- | --- | --- | --- |
| Kernel executable and linking format (ELF) |  |  | Output kernel ELF with debug symbols. |
| Initramfs |  |  | Initramfs in copy in, copy out (CPIO) file format. |
| Kernel image |  |  | Kernel raw image binary, systemd-boot does not support compressed images. |
| Kernel modules | Different kernel dynamically loadable kernel modules (DLKMs) |  | Kernel drivers modules. |
| Device tree blobs |  |  | Individual device tree blobs. |
| ESP partition |  |  | All required boot images including systemd-boot, kernel, and initramfs are packaged into the extensible firmware interface (efi.bin) binary. |
| DTB partition |  |  | All the DTBO files are packaged in dtb.bin binary. |

Last Published: Apr 27, 2026

[Previous Topic
Kernel overview](https://docs.qualcomm.com/bundle/publicresource/80-80022-3/topics/overview.md) [Next Topic
Boot flow and architecture overview](https://docs.qualcomm.com/bundle/publicresource/80-80022-3/topics/boot-flow-and-architecture-overview.md)