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");

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

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:

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

2. 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

Target Preparation

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

You can also Visit other tutorials of Embedded Prep 

• Multithreading in C++
• Multithreading Interview Questions
• Multithreading in Operating System
• Multithreading in Java
• POSIX Threads pthread Beginner’s Guide in C/C++
• Speed Up Code using Multithreading
• Limitations of Multithreading
• Common Issues in Multithreading
• Multithreading Program with One Thread for Addition and One for Multiplication
• Advantage of Multithreading
• Disadvantages of Multithreading
• Applications of Multithreading: How Multithreading Makes Modern Software Faster and Smarter”
• Master CAN Bus Interview Questions 2025
• What Does CAN Stand For in CAN Bus?
• CAN Bus Message Filtering Explained
• CAN Bus Communication Between Nodes With Different Bit Rates
• How Does CAN Bus Handle Message Collisions
• Message Priority Using Identifiers in CAN Protocol