Forem: Devontae Reid

Creating a Character Device Driver for Raspberry Pi Using Buildroot

Devontae Reid — Sat, 15 Jun 2024 04:16:15 +0000

Introduction

Welcome to those who have read my previous posts, and a warm welcome to all who are new to my blog. As an embedded developer, I continue to navigate the complexities of learning embedded engineering. Imposter syndrome often makes me wonder if I truly grasp the concepts as well as my peers. I am committed to gaining more knowledge in order to overcome numerous challenges that may arise in the embedded world. In this article, I will introduce you to the world of character device drivers, understand their core concepts, and walk you through the steps of creating and building one for a Raspberry Pi using Buildroot.

Understanding Character Device Drivers

What is a Character Device Driver?

Character device drivers are a type of device driver that manage devices performing I/O operations sequentially. Character devices, on the other hand, deal with data streams, making them compatible with a variety of peripherals, like serial ports, keyboards, and custom hardware.

Key Concepts

Device Files: In Linux, character devices are represented by device files located in the /dev directory. These files provide an interface for user-space applications to interact with the hardware.
Major and Minor Numbers: Each device file contains both a Major and Minor Number. The major number identifies the driver associated with the device, while the minor number identifies the specific device handled by the driver.
File Operations: Character device drivers define a set of file operations, such as open, close, read, write, and ioctl, to handle interactions between the user-space and the hardware.

Creating a Character Device Driver

Prerequisites

Before you embark on your development adventure, make sure you have the basic setup below:

A Linux development environment (preferably Ubuntu or similar).
Basic knowledge of C programming and Linux kernel modules.
Root access to the system for module loading and device file creation.
A Raspberry Pi board.
Buildroot configured for the Raspberry Pi.

Step 1: Setting Up Buildroot for Raspberry Pi

First, download and configure Buildroot for your Raspberry Pi as described in the previous article excluding the building step for the moment.

Step 2: Writing the Driver Code

Create a directory within your Buildroot package directory for your driver code:

mkdir -p buildroot/package/simple_char_driver
cd buildroot/package/simple_char_driver
touch char_driver.c

Open char_driver.c in your preferred text editor:

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/uaccess.h>

#define DEVICE_NAME "char_device"
#define BUFFER_SIZE 1024

#define CHAR_DEBUG_PRINT(fmt, ...) printk(KERN_INFO "CHAR_DRIVER_INFO: " fmt, ##__VA_ARGS__)

static int major_number;
static char device_buffer[BUFFER_SIZE];
static int open_count = 0;

static int device_open(struct inode *inode, struct file *file) {
    open_count++;
    CHAR_DEBUG_PRINT("Device opened %d times\n", open_count);
    return 0;
}

static int device_release(struct inode *inode, struct file *file) {
    CHAR_DEBUG_PRINT("Device closed\n");
    return 0;
}

static ssize_t device_read(struct file *file, char __user *user_buffer, size_t size, loff_t *offset) {
    int bytes_read = size < BUFFER_SIZE ? size : BUFFER_SIZE;
    if (copy_to_user(user_buffer, device_buffer, bytes_read)) {
        return -EFAULT;
    }
    return bytes_read;
}

static ssize_t device_write(struct file *file, const char __user *user_buffer, size_t size, loff_t *offset) {
    int bytes_to_write = size < BUFFER_SIZE ? size : BUFFER_SIZE;
    if (copy_from_user(device_buffer, user_buffer, bytes_to_write)) {
        return -EFAULT;
    }
    return bytes_to_write;
}

static struct file_operations fops = {
    .open = device_open,
    .release = device_release,
    .read = device_read,
    .write = device_write,
};

static int __init char_device_init(void) {
    major_number = register_chrdev(0, DEVICE_NAME, &fops);
    if (major_number < 0) {
        CHAR_DEBUG_PRINT("Failed to register a major number\n");
        return major_number;
    }
    CHAR_DEBUG_PRINT("Registered with major number %d\n", major_number);
    return 0;
}

static void __exit char_device_exit(void) {
    unregister_chrdev(major_number, DEVICE_NAME);
    CHAR_DEBUG_PRINT("Unregistered device\n");
}

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Dev Reid");
MODULE_DESCRIPTION("A simple character device driver");
MODULE_VERSION("0.1");

module_init(char_device_init);
module_exit(char_device_exit);

Step 3: Integrating the Driver with Buildroot

Create a Config.in file in the simple_char_driver directory:

touch Config.in

Edit Config.in:

config BR2_PACKAGE_SIMPLE_CHAR_DRIVER
    bool "Simple Character Device Driver"
    help
      This is a simple character device driver example for my raspberry pi 4.

Create a simple_char_driver.mk file in the same directory:

touch simple_char_driver.mk

Edit simple_char_driver.mk:

################################################################################
# Simple Character Device Driver Buildroot Package Makefile
################################################################################

# Define package variables
SIMPLE_CHAR_DRIVER_VERSION = 0.1
SIMPLE_CHAR_DRIVER_SITE = $(TOPDIR)/package/simple_char_driver
SIMPLE_CHAR_DRIVER_SITE_METHOD = local
SIMPLE_CHAR_DRIVER_LICENSE = GPL-2.0+
SIMPLE_CHAR_DRIVER_LICENSE_FILES = char_driver.c

# Path to the Buildroot cross-compiler
CROSS_COMPILE := $(TOPDIR)/output/host/usr/bin/arm-buildroot-linux-gnueabihf-

# Define build commands
define SIMPLE_CHAR_DRIVER_BUILD_CMDS
 $(MAKE) -C $(LINUX_DIR) M=$(SIMPLE_CHAR_DRIVER_BUILD_DIR) ARCH=arm CROSS_COMPILE=$(CROSS_COMPILE)
endef

# Define install commands
define SIMPLE_CHAR_DRIVER_INSTALL_TARGET_CMDS
 $(INSTALL) -D -m 0755 $(SIMPLE_CHAR_DRIVER_BUILD_DIR)/char_driver.ko $(TARGET_DIR)/lib/modules/char_driver.ko
endef

# Define clean commands
define SIMPLE_CHAR_DRIVER_CLEAN_CMDS
 $(MAKE) -C $(LINUX_DIR) M=$(SIMPLE_CHAR_DRIVER_BUILD_DIR) ARCH=arm CROSS_COMPILE=$(CROSS_COMPILE) clean
endef

# Set directory variables
SIMPLE_CHAR_DRIVER_BUILD_DIR := $(BUILD_DIR)/simple_char_driver-$(SIMPLE_CHAR_DRIVER_VERSION)

# Evaluate kernel module and generic package rules
$(eval $(kernel-module))
$(eval $(generic-package))

Create a Makefile file in the same directory:

touch Makefile

Edit Makefile:

obj-m += char_driver.o

# Path to the kernel source
KERNELDIR := $(SIMPLE_CHAR_DRIVER_SITE)

# Compilation flags
ccflags-y := -DDEBUG -g -std=gnu99 -Wno-declaration-after-statement

.PHONY: all clean

all:
    $(MAKE) -C $(SIMPLE_CHAR_DRIVER_SITE) M=$(PWD) modules

clean:
    $(MAKE) -C $(SIMPLE_CHAR_DRIVER_SITE) M=$(PWD) clean

Add the package to Buildroot's package/Config.in:

cd ..
echo "source \"package/char_device_driver/Config.in\"" >> Config.in

Step 4: Building the Driver with Buildroot

Reconfigure Buildroot to include your driver:

cd ..
make menuconfig

Navigate to:

Simple Device Driver and enable it.

Build the Buildroot system:

make

After two hours later...

Verify that the kernel module file (char_driver.ko) was added to the rootfs. There are two methods to verify this, and they should have the same output:

This can be done by check the current folder output/target/lib/modules.
Or you can mount the rootfs.ext4:

sudo mount -o loop output/images/rootfs.ext4 /mnt

Check the lib/modules folder

Step 5: Running the Driver on Raspberry Pi

Flash the Buildroot image to your SD card and boot your Raspberry Pi with it.
Load the driver module:

insmod /lib/modules/$(uname -r)/char_driver.ko

Create the device file:

mknod /dev/char_device c <major_number> 0
chmod 666 /dev/char_device

Replace <major_number> with the major number from the kernel log. To read the logs from the module, use the following command:

dmesg | grep char_device

Test the driver:

echo "Hello, Device!" > /dev/char_device
cat /dev/char_device

Step 6: Unloading the Driver

When you're done, unload the driver:

rmmod char_driver

Remove the device file:

rm /dev/char_device

Conclusion

Understanding the core concepts of device files, major and minor numbers, and file operations is important for creating a character device driver for Raspberry Pi using Buildroot. You can build and test a character device driver on your Raspberry Pi by following the instructions in this article. This fundamental understanding paves the way for more intricate driver development and deeper interactions with hardware components in embedded systems.

SOLI DEO GLORIA

Helpful Articles:

Writing and Inserting a 'Hello World' Kernel Module for the Beaglebone Black (Buildroot)

Exploring SoC and MPSoC: Understanding Integrated Circuit Architectures

Devontae Reid — Sat, 30 Mar 2024 16:16:55 +0000

Introduction

Welcome back to those who have read my previous posts, and a warm welcome to those who are new! As I continue to work as an embedded developer, navigating through the intricacies of SoC and MPSoC architectures, I often find myself grappling with imposter syndrome, wondering if I truly grasp the concepts as well as my peers. My aspiration is to enhance my comprehension and overcome numerous challenges that may arise.

In the world of integrated circuits(ICs), the terms 'system-on-chip(SoC)' and'multi-processor system-on-chip(MPSoC)' are common. We'll explore the fundamentals of SoC and MPSoC, explore their key features, and highlight the differences between them.

Understanding System-on-Chip (SoC)

A system-on-chip (SoC) is an integrated circuit (IC) that unites all the parts of a computer or electronic device onto a single chip. The SoC usually has a central processing unit (CPU), memory, input/output (I/O) interfaces, and peripherals.

This makes them suitable for a wide range of applications, including smartphones, tablets, IoT devices, and other embedded systems.

The best feature of SoCs is their consolidation of multiple hardware components onto a single chip, which allows for reducing system complexity, size, and power consumption vs. traditional multi-chip solutions.

Some of the leading vendors in the SoC market include:

Qualcomm
MediaTek
Samsung Electronics
Broadcom

Exploring Multi-Processor System-on-Chip (MPSoC)

The multiprocessor system of computers (MPSoCs) is designed to integrate multiple processing units (CPUs or cores) into a single chip, along with other components such as memory, I/O interfaces, and accelerators.

MPSoCs achieve better performance and efficiency, as well as superior scalability compared to traditional SoCs. Multiple tasks, enhanced throughput, and adeptly handle intricate workloads are some of the applications where MPSoCs are used. MPSoCs are deployed in applications such as data centers, networking equipment, automotive systems, industrial automation, and consumer electronics.

Some of the leading vendors in the MPSoC market include:

Xilinx
Intel
NVIDIA

Distinguishing Between SoC and MPSoC

Though SoC and MPSoC share resemblances in consolidating multiple components onto a single chip, their primary disparities lie in the number of processing units and their emphasis on parallel processing capabilities.

Wait what? I thought SoC has only one processing unit with many peripherals. How come there can be a CPU and a graphics processing unit (GPU) on the same chip?

That is true, while SoCs often integrate a CPU and GPU along with other components onto a single chip, the distinction lies in the emphasis on parallel processing capabilities and the integration of multiple types of processing units specifically for that purpose.

Another disparity lies in the versatility and customization options presented by MPSoCs, enabling developers to tailor the hardware architecture to meet precise application requisites, whereas SoCs are often optimized for specific applications or use cases.

Conclusion

The difference between SoC and MPSoC is important for choosing the appropriate architecture for diverse applications and fully using the potential of ICs. SoC furnishes complete computing functionality within a singular chip, while MPSoC extends this concept by combining multiple processing units for enhanced performance. Discerning the disparities between SoC and MPSoC is imperative for electing the appropriate architecture for diverse applications and fully harnessing the potential of IC technologies in the swiftly evolving computing landscape.

Let's embark on an enlightening journey together, feel free to reach out on LinkedIn or send a DM on Twitter.

Resources

Cover Photo from Android Authority

Soli Deo Gloria!

Build a Simple Linux Kernel Using Buildroot

Devontae Reid — Tue, 27 Feb 2024 00:28:27 +0000

Introduction

Welcome to this guide on how to build a Linux kernel using Buildroot!

This guide will give you a basic introduction to Linux kernel development. By the end of this guide you will know how to set up a Buildroot project, config the project, and flash the image to an SD card and have it running on a Raspberry Pi.

Prerequisites

Before you embark on your Buildroot adventure, make sure your PC isn't begging for more space because of all the memes and apps you don't use.

Aim for at least ~35GB of free space.

Ensure that you have the necessary packages on your Linux machine found in the requirements section within Buildroot Doc

Some minimal familiarity with Embedded Systems and Linux Ubuntu OS, as this will be the main OS we will be using.

Before we start, we need to understand what Buildroot is, and I'll make sure for it to be short and sweet!

What is Buildroot?

To use their own definition, "Buildroot is a simple, efficient and easy-to-use tool to generate embedded Linux systems through cross-compilation.". Cross-compilation is basically building software (SW) on one platform to be used on another platform.

Now, let’s get this started!

Building a Linux Kernel

Clone the GitHub repo to download Buildroot using the following command.



$ git clone https://gitlab.com/buildroot.org/buildroot.git

Once downloaded, open the newly created buildroot directory.



$ cd buildroot

Grab the configuration file.



$ make rasberrypi4_defconfig

This will create a config.in file into your local buildroot directory.

Time to config the kernel configuration. Run make menuconfig to access Buildroot's configuration menu. Here, specify the target architecture, select desired packages and features, and configure any custom settings according to your project requirements.

For my case, I will just be updating the startup boot manager. This is found in System Configuration -> System banner



$ make menuconfig

Navigate to System Configuration and update System banner

Exit and save your kernel config

Build your kernel



$ make

After two hours later...

You should have your bootable image inside the output/images directory that you can add to your SD card

Insert the SD card into the Raspberry Pi 4 and power it on to boot into the custom Linux system.

Conclusion

By following these steps and along with installing the prerequisites, you will have everything you need to build a simple Linux kernel using Buildroot.

I can’t wait to see what you’ll build; if you follow these steps and get stuck or have any questions, feel free to reach out on LinkedIn or send a DM on Twitter.

Cover Photo by Stefan Cosma on Unsplash