Linux Device Driver Programming With Beaglebone Black (LDD1)

Explore Linux kernel modules and write a simple hello world module. Learn to compile, transfer to BeagleBone Black, and load or unload dynamically with insmod, modprobe, and rmmod.

Distinguish user space from kernel space in Linux, where privileged mode lets kernel code access memory and peripherals. Learn how user programs request services via system calls to kernel drivers.

Learn to write your first kernel module, including header and code sections, module initialization and cleanup entry points, and the use of __init and __exit with insmod and rmmod.

Explain how __init and __exit macros translate to compiler directives placing code in .init and .exit, while the build system excludes __exit and __initdata, leaving non-__init code in .text.

Register module entry points with module_init and module_exit, declare license, author, and description via macros, and note GPL versus non GPL taint and metadata tools modinfo and objdump.

Create a hello world module, test it, and learn how to build it. Implement helloworld_init and helloworld_cleanup, include kernel headers, and print with pr_info on Beagle bone black REV A5.

Learn to build a linux kernel module, including dynamically loadable and in-tree options. Distinguish out-of-tree modules, and use kbuild with make -C and M to guide the build.

Build a hello_world linux kernel module with a Makefile and obj-m, compiling against the host kernel sources. Load with insmod, view dmesg for init messages, and remove with rmmod.

Cross compile the kernel module for the Beagle bone black using a target kernel source, transfer the .ko to the board, then load it and observe Hello world in dmesg.

Automate kernel module builds for Beaglebone Black by creating a makefile with targets like all and host, using ARCH, CROSS_COMPILE, KERN_DIR, and M=$(PWD).

Learn to build an in-tree kernel module by adding it to the Linux kernel source, configuring with Kconfig and menuconfig, and compiling with make to produce a .ko.

Learn to debug in kernel space with printk, the kernel's printf-like API, using kernel log levels, dmesg, and wrapper macros like pr_info to print messages to the kernel log.

Explore how a device driver configures hardware, handles registers and interrupts, and exposes user-space interfaces via device files. Focus on character drivers and kernel interactions.

Develop a character device driver that connects user space open, read, and write calls to hardware via the VFS, and manage major/minor numbers with alloc_chrdev_region and cdev_add.

Learn to use alloc_chrdev_region() to dynamically allocate a range of character device numbers, including a dynamically assigned major, a dev_t first number, and optional minor count.

Develop a pseudo character driver by creating a single device, allocating a device number with alloc_chrdev_region, and using a 512-byte memory pool for read and write operations.

Register a character device with cdev_init and cdev_add, linking the driver’s file_operations to the VFS so user-space calls reach open, read, write, and seek, with the owner set to THIS_MODULE.

Register a cdev with the kernel vfs via cdev_add and the device number from alloc_chrdev_region, with one minor. Avoid owner initialization in cdev_init and prepare for creating device files next.

Explore character driver file operations, implementing open, close, read, write, and lseek via the driver's file_operations and cdev, and trace the path from device file creation to driver methods.

Learn character driver file operations, including how the VFS passes inode and file object to pcd_open and pcd_release, and how pcd_read, pcd_write, and pcd_lseek manage f_pos and SEEK_SET/CUR/END.

Implement the character driver's file operation methods by copying prototypes from linux/fs.h's file_operations structure, initialize llseek, read, write, open, and release, paste into main.c, then build with make.

Learn to initialize the file_operations structure in a Linux kernel module using C99 designated initializers, assigning open, read, write, llseek, and owner to THIS_MODULE.

Explore dynamic device file creation in linux by using class_create and device_create to export major and minor numbers to sysfs, enabling udev to create /dev entries automatically.

Learn to implement the character driver cleanup function by unloading the driver with rmmod and removing resources in reverse init order: device_destroy, class_destroy, cdev_del, and unregister_chrdev_region using the device number.

Understand how to implement the read method for a pseudo character device backed by a 512-byte memory buffer, including DEV_MEM_SIZE checks, copy_to_user, f_pos handling, and end-of-file behavior.

Explain how to choose and return appropriate error codes from kernel space to user space, using errno and errno-base.h, with examples like EFAULT and ENOMEM during read and copy_to_user.

Implement the read method by adjusting count, using copy_to_user to the destination user buffer, and updating the file position within DEV_MEM_SIZE limits, with error handling via -EFAULT.

Implement the write method by copying data from user space to the device memory buffer using copy_from_user, mirroring the read method, and return bytes written or ENOMEM when full.

Implement the write method by adapting the read method, using copy_from_user to transfer data into device_buffer, handle ENOMEM for zero or invalid counts, and update the file position.

Implement the lseek method for a Linux device driver using the VFS-provided file object, offset, and whence; handle SEEK_SET, SEEK_CUR, and SEEK_END with a 512-byte device.

Implement the lseek method for a Linux device driver, handling whence values (SEEK_SET, SEEK_CUR, SEEK_END), updating f_pos with offset while enforcing DEV_MEM_SIZE bounds and returning -EINVAL on invalid seeks.

Test a pseudo character device driver by compiling for host, loading the pcd driver, and exercising open, write, read, and memory behavior on a 512-byte device.

Demonstrate error handling in Linux kernel module initialization using if and goto, with IS_ERR and PTR_ERR, to clean up resources during device and class creation.

Develop a single pcd driver that handles four devices (pcdev-1 to pcdev-4) with open, read, write, release, and lseek, using per-device private data to manage static memory and permissions.

Extend the pcd driver to support four devices by duplicating buffers and adding per-device private data, reusing the earlier pcd.c and makefile.

Compile early and often, use if and endif to disable code, and initialize driver private data with per-device pcdev data and device buffers for four devices.

Implement pcd_driver_init by dynamically allocating four device numbers with alloc_chrdev_region, initializing and adding each cdev in a loop, and creating devices named pcdev-0 to pcdev-3 via a single class.

Improve the pcd driver with multiple devices by implementing a robust init and cleanup that handles failures using unregister_chrdev_region, cdev_add, device_create, device_destroy, and class_destroy across all devices.

Implement the pcd_open method to identify the targeted device via inode i_rdev and minor number, use container_of to fetch pcdev_private_data from inode's cdev, and store it in the file's private_data.

implement read, write, and lseek methods for the multi-device pcd driver, using the private data to determine max size and copying data to and from the user buffer.

implement a check_permission function in the pcd driver to enforce read, write, or read-write access using f_mode and the read/write mode macros.

Test the pcdev driver with multiple devices, loading it via insmod and verifying /dev entries. Explore write and read operations, EPERM and NOMEM errors, and debug with dd and strace.

Explore reading data from a device file with dev_read.c: open pcdev-3, loop reads with a remaining counter, handle errors, and test via command-line readcount.

Examine the lseek method in the pcd driver, using fd, offset, and whence (seek set, cur, end); test valid and invalid seeks and initialize llseek in file operations.

Explore how the container_of macro computes a container address from a member pointer, implement a custom macro, use offset and offsetof, and compare to kernel style safety checks.

Explore platform devices and drivers in Linux device driver programming, detailing platform bus, non-discoverable devices, and how device tree enables hardware information to the kernel.

Learn about platform drivers on the AM335x SoC in the BeagleBone Black, including I2C, SPI, and other on‑chip peripherals, and the distinction between devices and controllers, with vendor‑provided controllers.

Register a platform driver and device with the Linux kernel, explore the matching mechanism, and implement probe and remove functionality for robust platform driver support.

Implement a platform driver as a pseudo character driver for platform devices, with open, read, write, lseek. Add modules for platform driver and platform device setup, with probe and remove.

Create two platform devices and supply per-device data (size, permission, serial_number) via a pcdev_platform_data struct, attaching it to each device and registering with platform_device_register.

Initialize the platform_device release callback to free resources on removal. Implement pcdev_release and verify two devices appear under /sys/devices/platform.

implements the platform driver skeleton by adding probe and remove callbacks, registers the driver with platform_driver_register, and aligns the driver name with the platform device for automatic probing.

Implement and debug platform driver code by adding probe and remove prints, ensuring correct device name matching, observing probe calls for two devices, and understanding module load/unload order and cleanup.

Explain platform driver data structures, including driver private data and device private data, and implement init and cleanup using alloc_chrdev_region, device_num_base, and class creation.

Implements the platform driver probe function, extracts platform data, allocates device private data with kzalloc, allocates device buffer using kernel memory APIs, and prepares cdev init and device file setup.

dynamically allocate the platform device buffer, free it with kfree on error, initialize private data and device number from pdev id, then cdev_init, cdev_add, and device_create.

Implement the remove function to clean up memory by retrieving the device private data via dev_get_drvdata, destroying the cdev, and freeing the device buffer and private data.

Build and test the platform driver and device_setup.ko, observe probe messages with dmesg, and verify cleanup via remove and release, ensuring proper device unregistration and driver unloading.

Master resource managed kernel APIs like devm_kmalloc, devm_gpiod_get, and devm_request_irq to allocate memory and resources on behalf of a device, simplifying probe and remove functions and ensuring automatic cleanup.

Leverage resource management kernel APIs to automate memory cleanup in device drivers, using devm_kzalloc and devm_kmalloc to replace kzalloc, avoid memory leaks, and simplify cleanup in probe and remove.

Learn to add multiple platform devices with platform_add_devices, pass an array of platform_device structures via ARRAY_SIZE, and verify probes for all devices.

Resolve a kernel crash by fixing duplicate device files and registering four devices, then verify probe success and data transfer between user space and kernel space using pcdev0–pcdev3.

Explore how platform device ids enable a single driver to support multiple versions, using a platform_device_id table for A1x, B1x, and C1x, with driver_data in probe to configure each device.

Streamline error handling in the probe function by relying on devres_release_all for cleanup and returning on error, removing goto and unnecessary deletions.

Explore the device tree, a data exchange format that decouples hardware description from the Linux kernel to enable runtime topology discovery and data-driven device drivers.

Write device trees by following the official device tree specification, using a hierarchical, modular approach with soc-specific dtsi includes and board-specific dts for Beaglebone and AM335x boards.

Understand the device tree structure with a root node and root slash, through parent-child relationships and properties, and learn the syntax for dts/dtsi and board-specific overrides.

Learn the syntax for writing device tree nodes, including node-name@unit-address, reg properties, and addressing rules, with emphasis on labels, non-standard vs standard properties, and memory-map context.

Visualize hardware details as device tree nodes, with i2c0 as the parent and two children, tps@0x24 and eeprom@0x50, and see how reg encodes their i2c addresses.

Learn how device tree properties use key-value pairs to describe a node, distinguish standard and non-standard properties, and instantiate four pseudo character devices from the device tree on Beaglebone Black.

The compatible property in device trees uses a string list to guide Linux driver matching, machine identification, and probe invocation for devices such as i2c controllers and eeproms.

Explain how device tree bindings document the properties required by Linux drivers, show how to use binding documents for i2c, lm75, and mpu6050, and outline naming and formatting conventions.

Rewrite the pseudo character driver to instantiate four pcdev devices from the device tree, adding four device nodes with size, serial number, and permission.

Switch to Linux kernel version 5.4 by checking out the 5.4 branch and compiling the kernel, modules, and kernel image for your board.

Update the Beaglebone Black kernel to 5.4 by backing up and replacing uImage and am335x-boneblack.dtb, then copy 5.4.47 modules and boot the board.

Explains adding pcdev-1 to pcdev-4 device tree nodes in am335x-boneblack.dts, with an include file and org-prefixed properties, then compiling with the device tree compiler to a dtb for boot.

Bind four device tree nodes to a platform driver using an of_match_table and probe to read dt properties, then test by updating the device tree on the Beaglebone board.

Test device tree changes by adding a compatible property, compile am335x-boneblack.dtb, transfer it and the driver to the board, then load the driver and verify probe for four pcdev devices.

Extend a Linux pcd platform driver probe to support device tree and device setup instantiation, extract platform data from the device tree, allocate pdata, and derive driver_data via match data.

Demonstrates implementing a pcd platform driver with device tree, fixes crashes by replacing pdev->id with total_devices, and creates devices under a class with a parent. Shows testing via device_setup, loading and removing the driver, and observing eight pcdev devices under /dev and platform topology, and highlights dev_info versus pr_info for logs.

Explore CONFIG_OF and device tree support in Linux kernels, learn how Open Firmware processes device trees, and adapt a probe function using of_match_ptr and dummy stubs when CONFIG_OF is off.

Discover how device tree overlays patch the main dtb to enable hardware like lcd capes on beaglebone black. Create overlay dts, compile to dtbo, and apply changes via fragments.

Write and compile a device tree overlay (.dtbo) to disable or modify pcdev nodes in the main dts, then load the overlay at boot with uboot to update the dtb.

Configure u-boot for BeagleBone using the am335x_evm_defconfig, adjust the boot delay to five seconds in menuconfig, and cross-compile with the arm toolchain to generate the image.

Transfer the MLO and uboot.img to the board with scp, mount the root partition, back up the old image, copy the new files, and reboot to verify.

Apply dtbo overlays with u-boot by loading the am335x-boneblack.dtb and the PCDEV0.dtbo from mmc, then merge with fdt apply. Boot Linux manually and verify the overlay effects in /sys/devices/platform.

Automate device tree overlays on Beaglebone Black by editing uEnv.txt, defining overlay loading commands, and booting with multiple dtbo files to enable and test sequential devices.

Explore the Linux device model, a collection of data structures and helpers that unify buses, devices, and drivers via sysfs at /sysfs, with examples like platform_device and i2c_client.

Explore kobjects, the kernel objects embedded in container structures like bus, device, and device_driver, and learn their reference counting with kref and their release role in sysfs.

Explore kobject type and kset in the Linux sysfs, where struct kobj_type defines shared behavior and default attributes for kobjects, while kset aggregates same-type kobjects to build the device hierarchy.

Explore sysfs and kobject attributes to expose device and driver data to userspace, navigate the kobject hierarchy, and implement custom attributes like max_size and serial_num.

Create and configure sysfs attributes in a Linux device driver using kobjects. Define two attributes, maxi_size and serial_number, with read and write via struct device_attribute and the DEVICE_ATTR macros.

Extend the pcd platform driver with sysfs support by moving system call handlers to pcd_syscalls.c, adding a header, and updating the makefile to build pcd_sysfs.

Learn to create two sysfs attributes in a Linux device driver for Beaglebone using DEVICE_ATTR with max_size and serial_number, implement show and store, and wire them with sysfs_create_file.

Remove previous drivers, load the device_setup to trigger the probe and create sysfs attributes like max_size and serial_num under /sys/class/pcd_class, preparing for read/write in the next lecture.

Understand how sysfs attributes use show and store methods to export values to user space and receive updates, handling buffers up to PAGE_SIZE (4 kilobytes) on ARM.

Implement and test sysfs show and store for serial_number and max_size in a BeagleBone Black Linux driver, accessing device private data and using kstrtol and krealloc.

Learn to group sysfs attributes with sysfs_create_group by building a struct attribute_group from a null terminated attribute array, enabling multiple attributes to be created in one call.