Tag: Hello World driver

  • How to Write Your First Hello World Driver with Yocto | Master Linux Driver Interview Question (2026)

    How to Write Your First Hello World Driver : Learn step-by-step how to write your first “Hello World” driver with Yocto. This beginner-friendly guide explains kernel module basics, creating a Yocto recipe, building with BitBake, and testing on your embedded Linux board.

    If you’re learning hello world yocto driver and want to understand how device drivers fit into an embedded Linux system, writing a simple Hello World driver is the best starting point. This article will guide you step by step on how to write, compile, and test a kernel module using Yocto.

    How to Write Your First Hello World Driver Step by Step

    Prerequisites for Writing a Hello World Driver with Yocto

    1. Basic Knowledge
      • Understanding of Linux basics (commands, file structure).
      • Some exposure to C programming (especially pointers and functions).
      • Awareness of what a kernel module is.
    2. Yocto Setup
      • A working Yocto build environment (Poky or a vendor BSP like meta-yocto, meta-ti, etc.).
      • You should be able to build at least a core-image-minimal successfully.
    3. Development Machine
      • Ubuntu (20.04 or 22.04 LTS) or Debian recommended.
      • Packages installed: sudo apt-get install gawk wget git-core diffstat unzip texinfo gcc \ build-essential chrpath socat cpio python3 python3-pip python3-pexpect \ xz-utils debianutils iputils-ping
    4. Target Hardware or Emulator
      • A real embedded board (e.g., BeagleBone Black, Raspberry Pi, STM32MP1, Qualcomm, etc.)
      • OR QEMU (Yocto supports running images in QEMU for testing).
    5. Cross-Compilation Knowledge
      • Basic idea of cross-compilation since Yocto builds software for a different architecture than your PC (e.g., ARM target vs x86 build machine).
    6. Kernel Source & Headers
      • Ensure your Yocto build has the kernel source available for building external modules (linux-yocto recipe).
    7. Bitbake & Layers
      • Familiarity with bitbake commands.
      • Knowledge of adding a custom layer using: bitbake-layers add-layer ../meta-myproject

    Git Clone Methods in Yocto Setup

    When working with Yocto, you usually clone the Poky repository (the reference distribution of Yocto). Depending on your internet and use case, you can use either HTTPS or SSH method.

    1. HTTPS Method (Recommended for Beginners)

    This is the easiest and most common. No special keys required.

    git clone git://git.yoctoproject.org/poky
    

    or sometimes:

    git clone https://git.yoctoproject.org/git/poky
    

    👉 Use this if you’re just learning and don’t want to deal with SSH keys.

    2. SSH Method (For Contributors/Advanced Users)

    If you plan to contribute to Yocto or push code, you need an SSH key.

    git clone git@yoctoproject.org:poky
    

    👉 Use this if you have a developer account with Yocto Project and want to push patches.

    3. Cloning a Specific Yocto Release

    Yocto has releases like dunfell, kirkstone, mickledore, etc. After cloning, you can check out a stable branch:

    cd poky
    git checkout kirkstone
    

    👉 Always use an LTS (Long-Term Support) branch if you’re learning (e.g., kirkstone is an LTS release).

    4. Shallow Clone (Faster, Less Disk Space)

    The Yocto repo is big. If you just want the latest branch, use:

    git clone --branch kirkstone --depth=1 git://git.yoctoproject.org/poky
    

    👉 This avoids downloading the full history.

    For Your Hello World Driver Project

    I recommend:

    git clone https://git.yoctoproject.org/git/poky
    cd poky
    git checkout kirkstone   # or the LTS release your board supports
    

    Then add BSP layers for your board (e.g., meta-raspberrypi, meta-ti).

    Step 1: What is Yocto?

    The Yocto Project is a build system for creating custom Linux distributions for embedded devices. It allows you to create minimal Linux images and include your own applications, libraries, and drivers.

    When working with Yocto, you usually create recipes (.bb files) that tell Yocto how to build and install your software.

    Step 2: Write a Simple “Hello World” Linux Driver

    Let’s create a very basic Linux kernel module (driver).

    👉 Create a file named hello.c

    #include <linux/init.h>      // For module init/exit macros
    #include <linux/module.h>    // For all kernel modules
    #include <linux/kernel.h>    // For printk()
    
    static int __init hello_init(void)
    {
        printk(KERN_INFO "Hello, World from Yocto Driver!\n");
        return 0;
    }
    
    static void __exit hello_exit(void)
    {
        printk(KERN_INFO "Goodbye, World from Yocto Driver!\n");
    }
    
    module_init(hello_init);
    module_exit(hello_exit);
    
    MODULE_LICENSE("GPL");
    MODULE_AUTHOR("Beginner");
    MODULE_DESCRIPTION("A Simple Hello World Driver for Yocto");
    
    How to Write Your First Hello World Driver with Yocto Write a Simple "Hello World" Linux Driver

    This driver simply prints a message when it is loaded and unloaded.

    Step 3: Create a Makefile

    Create a file named Makefile in the same directory:

    obj-m += hello.o
    
    all:
    	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
    
    clean:
    	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
    
    How to Write Your First Hello World Driver with Yocto  Makefile

    This allows you to build the kernel module outside the Yocto environment first (just to test).

    Run:

    make
    

    This will generate a file hello.ko (the kernel object module).

    👉 You can load it manually using:

    sudo insmod hello.ko
    dmesg | tail
    

    And remove it using:

    sudo rmmod hello
    dmesg | tail
    

    Step 4: Create a Yocto Recipe for Your Driver

    Now let’s integrate this driver into Yocto.

    Inside your Yocto layer (for example meta-myproject/), create a folder for your driver:

    How to Write Your First Hello World Driver with Yocto | RTOS Interview Question (2025)

    hello.bb (Recipe File)

    DESCRIPTION = "Simple Hello World Kernel Module"
    LICENSE = "GPLv2"
    LIC_FILES_CHKSUM = "file://hello.c;beginline=12;endline=22;md5=3c3e73c4e3f1c0b1c2b0ed8cfae1a777"
    
    SRC_URI = "file://hello.c \
               file://Makefile"
    
    S = "${WORKDIR}"
    
    inherit module
    
    

    Here:

    • inherit module tells Yocto it’s a kernel module.
    • SRC_URI tells Yocto where to find your driver files.

    Step 5: Build with Yocto

    1. Add your layer to Yocto:
    bitbake-layers add-layer ../meta-myproject
    1. Build your driver:
    bitbake hello
    

    After build, the module hello.ko will be available in the Yocto output.

    Step 6: Test the Driver on Target

    Copy the generated .ko file to your embedded board:

    scp tmp/deploy/ipk/*/hello_*.ipk user@board:/home/root/
    

    On the board, install and test:

    opkg install hello_*.ipk
    insmod hello.ko
    dmesg | tail
    

    You should see:

    Hello, World from Yocto Driver!
    

    When removing:

    Goodbye, World from Yocto Driver!
    

    Application Code

    #include <stdio.h>
    int main() {
        printf("Hello, Yocto Krikstone!\n");
        return 0;
    }
    

    Flashing of SD Card using Card Reader USB to SD Card Reader

    How to Write Your First Hello World Driver with Yocto  a)  SD Card Reader
    How to Write Your First Hello World Driver with Yocto  b) balena Tool to flash SD Card

    Target Preparation

    How to Write Your First Hello World Driver with Yocto  c) HW Connection
    How to Write Your First Hello World Driver with Yocto  d) output from serial console

    Conclusion

    Congratulations! 🎉 You just wrote your first Hello World driver with Yocto.

    • You learned how to write a basic Linux kernel module.
    • You created a Yocto recipe for your driver.
    • You built and tested it on your target board.

    This is the foundation. From here, you can extend your driver to work with real hardware like GPIO, I2C, or sensors.

    FAQ Writing Hello World Driver with Yocto

    1. What is Yocto used for?

    Ans: Yocto is a build system that helps developers create custom Linux distributions for embedded devices. It allows you to add drivers, applications, and libraries into your Linux image.

    2. What is a Hello World driver in Linux?

    Ans: A Hello World driver is the simplest Linux kernel module that just prints a message when loaded and unloaded. It helps beginners understand how kernel modules work.

    3. Do I need Yocto to write a Hello World driver?

    Ans : No, you can first write and test it on any Linux system using insmod and rmmod. Yocto is used when you want to integrate the driver into your embedded Linux distribution.

    4. What is the difference between a driver and a kernel module?

    Ans: A driver is a program that lets the kernel communicate with hardware. A kernel module is a piece of code that can be loaded into the Linux kernel at runtime—many drivers are kernel modules.

    5. How do I compile a Hello World driver in Linux?

    Ans: You write the driver code in C, create a Makefile, and run make to build a .ko (kernel object) file. Then use insmod to insert it and dmesg to check messages.

    6. How do I add a driver to Yocto?

    Ans: You create a recipe (.bb file) in a Yocto layer. The recipe tells Yocto how to compile and package your driver. Then you run bitbake to build it.

    7. What is a Yocto recipe?

    Ans: A recipe (.bb file) is a set of instructions used by Yocto to fetch, build, and package software like drivers or applications.

    8. Where can I find the Hello World driver after building with Yocto?

    Ans: Yocto puts the compiled driver (.ko file or .ipk package) in the tmp/deploy/ folder inside your build directory.

    9. How do I test my Yocto driver on the target board?

    Ans: Copy the .ko or .ipk file to your embedded board, use insmod to load the driver, and check logs with dmesg.

    10. Can I extend the Hello World driver to control real hardware?

    Ans: Yes ✅. Once you learn the basics, you can modify the driver to handle GPIO, I2C, SPI, or sensors. This is the next step after the Hello World driver.
    How to Write Your First Hello World Driver with Yocto
    How to Write Your First Hello World Driver with Yocto RTOS Interview Question (2025)
  • Master Hello World using Yocto | Build & Run a Linux Kernel Driver on BeagleBone Black (2026)

    Hello World using Yocto : Learn how to build a simple “Hello World” Linux kernel module from scratch using the Yocto Project for the BeagleBone Black. This step-by-step guide covers everything you need — from installing essential build tools, cloning the Yocto and meta-ti layers, creating a custom meta layer for your kernel module, writing the driver code, creating the recipe, to building and deploying the image on your BeagleBone Black device. Perfect for embedded Linux developers and beginners, this tutorial ensures you understand how to integrate and run out-of-tree kernel modules efficiently using Yocto’s powerful build system.

    What is Yocto?

    Yocto Project is an open-source collaboration project that helps developers create custom Linux-based systems for embedded devices. It provides tools, templates, and methods to build your own Linux distribution tailored to your hardware and software needs.

    Why use Yocto?

    • Custom Linux builds: You can create a Linux system optimized for your specific hardware (like BeagleBone Black, Raspberry Pi, etc.).
    • Reproducible builds: You can reproduce the exact same Linux image anytime.
    • Cross-compilation: It simplifies building software on your desktop machine for another target platform.
    • Scalability: Use it for small embedded devices or large, complex systems.
    • Community support: Backed by many companies and contributors in the embedded world.

    Key components of Yocto

    • BitBake: The build engine (like make but more powerful for embedded Linux).
    • Poky: The reference distribution and set of metadata recipes.
    • Recipes: Scripts that define how to build packages, kernels, and images.
    • Layers: Collections of recipes and configuration that can be added to customize the build.

    Who uses Yocto?

    • Embedded system developers building custom Linux for hardware like automotive infotainment, IoT devices, industrial controllers, and more.
    • Companies wanting to maintain full control over their embedded Linux stack.

    What is Poky?

    Poky is the reference build system and distribution provided by the Yocto Project. It’s basically a set of metadata, tools, and configurations that you use as a starting point to build your own custom embedded Linux images.

    Details:

    • Poky = Yocto Project reference system
      It includes the BitBake build tool plus a collection of recipes, configuration files, and classes that define how to build software packages, the Linux kernel, and the overall system image.
    • It’s a base for your custom Linux
      When you start a Yocto Project build, most tutorials and examples use Poky because it’s a complete and tested setup.
    • Contains layers like:
      • meta: core metadata layer with basic recipes and configurations
      • meta-poky: specific poky configurations and utilities
      • meta-yocto: essential recipes for a minimal embedded Linux distribution

    Why is Poky important?

    • It’s the default “reference distro” for Yocto, meaning it provides a working baseline system.
    • You can extend or modify Poky with additional layers to support your hardware and software requirements.
    • It helps you understand how the Yocto build system works before diving into more complex customizations.

    What is BitBake?

    BitBake is the build engine/tool used by the Yocto Project (and Poky) to compile and assemble software components into a complete Linux image for embedded systems.

    Details:

    • It’s like “make” on steroids but designed specifically for building embedded Linux systems.
    • BitBake reads special files called recipes (.bb files), which describe how to fetch, configure, compile, and package software.
    • It manages complex build tasks, dependencies, and executes them in the right order.
    • BitBake supports cross-compilation, so you can build software on your development machine for a different target device.
    • It also handles layers, configuration, and task scheduling.

    Why is BitBake important?

    • It automates the entire build process for embedded Linux, from downloading source code to creating a final flashable image.
    • It ensures reproducibility — builds can be repeated with the same results.
    • BitBake is highly extensible and can be customized with your own recipes.

    Install Yocto Prerequisites

    On your Ubuntu/Debian build machine:

    sudo apt update
    sudo apt install -y gawk wget git-core diffstat unzip texinfo \
      gcc build-essential chrpath socat cpio python3 python3-pip python3-pexpect \
      xz-utils debianutils iputils-ping python3-git python3-jinja2 \
      libegl1-mesa libsdl1.2-dev pylint3 xterm
    

    These are the official Yocto host dependencies.

    Download Yocto (Poky) and BeagleBone BSP Layer

    We’ll use the Yocto Kirkstone LTS release and meta-ti for TI boards like the BBB.

    mkdir ~/yocto-bbb
    cd ~/yocto-bbb
    
    # Poky (Yocto core)
    git clone -b kirkstone git://git.yoctoproject.org/poky
    
    # TI BSP layer (BeagleBone support)
    git clone -b kirkstone git://git.yoctoproject.org/meta-ti
    

    Set Up the Build Environment

    cd poky
    source oe-init-build-env
    

    This creates and moves you into a build/ directory.

    Add BeagleBone Black Layers

    bitbake-layers add-layer ../meta-ti
    

    Set the Machine to BeagleBone Black

    Edit conf/local.conf:

    MACHINE = "beaglebone"
    

    Create Your Custom Layer for the Driver

    cd ~/yocto-bbb
    bitbake-layers create-layer meta-hello
    bitbake-layers add-layer ../meta-hello
    

    Create the Hello World Kernel Module

    Directory Structure:

    meta-hello/
    └── recipes-kernel/
        └── hello-module/
            ├── files/
            │   ├── hello.c
            │   ├── Makefile
            │   └── COPYING
            └── hello-module_0.1.bb
    

    hello.c

    #include <linux/module.h>
    #include <linux/kernel.h>
    #include <linux/init.h>
    
    MODULE_LICENSE("GPL");
    MODULE_AUTHOR("Nish");
    MODULE_DESCRIPTION("Hello World Kernel Module for BeagleBone Black");
    
    static int __init hello_init(void)
    {
        printk(KERN_INFO "Hello, BeagleBone World!\n");
        return 0;
    }
    
    static void __exit hello_exit(void)
    {
        printk(KERN_INFO "Goodbye, BeagleBone World!\n");
    }
    
    module_init(hello_init);
    module_exit(hello_exit);
    

    Makefile

    obj-m := hello.o
    

    COPYING

    GNU GENERAL PUBLIC LICENSE
    Version 2, June 1991
    

    Get its checksum:

    md5sum COPYING
    

    hello-module_0.1.bb

    SUMMARY = "Hello World Kernel Module for BeagleBone Black"
    DESCRIPTION = "A simple kernel module built with Yocto for BBB"
    LICENSE = "GPL-2.0"
    LIC_FILES_CHKSUM = "file://COPYING;md5=<paste-md5-here>"
    
    SRC_URI = "file://hello.c \
               file://Makefile \
               file://COPYING"
    
    S = "${WORKDIR}"
    
    inherit module
    

    Include the Module in the Image

    Edit conf/local.conf:

    IMAGE_INSTALL_append = " kernel-module-hello"
    

    (Optional: Auto-load at boot)

    KERNEL_MODULE_AUTOLOAD += "hello"
    

    Build the Image

    cd ~/yocto-bbb/poky
    source oe-init-build-env
    bitbake core-image-minimal
    

    After the build completes, the image will be in:

    tmp/deploy/images/beaglebone/
    

    Flash to SD Card

    Insert your SD card and find its device name:

    lsblk
    

    Flash:

    sudo dd if=tmp/deploy/images/beaglebone/core-image-minimal-beaglebone.wic of=/dev/sdX bs=4M status=progress
    sync
    

    Boot BeagleBone Black

    • Insert SD card into BBB
    • Power it up (hold BOOT button if needed to boot from SD)

    Test the Module on BBB

    # Check if auto-loaded
    lsmod | grep hello
    
    # If not, load manually
    sudo modprobe hello
    
    # Check kernel logs
    dmesg | tail
    
    # Remove module
    sudo rmmod hello
    dmesg | tail
    

    Expected output:

    [   15.123456] Hello, BeagleBone World!
    [   20.654321] Goodbye, BeagleBone World!
    

    ✅ You’ve successfully built, packaged, and run a Hello World Linux kernel driver on BeagleBone Black using Yocto!

    Frequently asked questions (FAQ) | Hello World using Yocto

    1. What is Yocto and why use it for building kernel modules?

    Yocto is a powerful open-source build system for creating custom Linux distributions for embedded devices like BeagleBone Black. Using Yocto to build kernel modules ensures reproducible builds, automatic packaging, and easy integration into your custom image.

    2. How do I install the necessary host tools for Yocto?

    On Ubuntu/Debian, run:

    sudo apt install gawk wget git-core diffstat unzip texinfo gcc build-essential chrpath socat cpio python3 python3-pip python3-pexpect xz-utils
    

    This installs all required tools and dependencies for Yocto to build properly.

    3. Why do I need to clone both ‘poky’ and ‘meta-ti’ repositories?

    ‘poky’ is the main Yocto reference distribution containing BitBake and core layers. ‘meta-ti’ provides board support packages (BSP) and recipes specific to Texas Instruments devices like the BeagleBone Black.

    4. How do I add my own kernel module to the Yocto build?

    Create a custom meta layer (meta-hello), add your kernel module source and recipe inside it, then add this layer to your build using bitbake-layers add-layer. Finally, append your kernel module package to IMAGE_INSTALL in local.conf.

    5. What does inherit module do in the recipe?

    It tells Yocto that this recipe builds a kernel module, so it sets up the proper build environment, compiles the code against the kernel headers, and packages the module correctly.

    6. How do I ensure my module loads automatically on boot?

    Set the variable KERNEL_MODULE_AUTOLOAD += "hello" in your local.conf or image recipe. Yocto will then create the necessary config files to load your module during system startup.

    7. What if my module doesn’t load or I get errors?

    • Check kernel logs with dmesg to see error messages.
    • Verify that the module is actually included in your image (IMAGE_INSTALL).
    • Make sure the kernel version on your target matches the one you built the module for.
    • Use modprobe instead of insmod to handle dependencies.

    8. How do I flash the Yocto-built image to the BeagleBone Black?

    Use dd to write the .wic image to your SD card:

    sudo dd if=core-image-minimal-beaglebone.wic of=/dev/sdX bs=4M status=progress && sync
    

    Replace /dev/sdX with your actual SD card device.

    9. Can I build and test the kernel module without building the entire image?

    Yes! You can build just the module by running:

    bitbake hello-module
    

    Then manually copy the resulting .ko file to the target and load it with insmod or modprobe.

    10. Where can I find more resources to learn Yocto and kernel module development?