This instructor-led course is designed to show experienced programmers how to develop device drivers for embedded Linux systems, and give them a basic understanding and familiarity with the Linux kernel.
INSTRUCTOR-LED COURSE
Developing Embedded Linux Device Drivers (LFD435)
Who Is It For
This course is for experienced developers who need to develop device drivers for embedded Linux systems.
read less
read more
What You’ll Learn
Upon mastering this material, you will be familiar with the different kinds of device drivers used under Linux, and have an introduction to many of the appropriate APIs to be used when writing a device driver. The labs for illustrating these concepts will all be performed on ARM hardware in order to get developers familiar with cross-compiling and developing drivers for an embedded target.
read less
read more
What It Prepares You For
This course will prepare you to develop device drivers for embedded Linux systems.
read less
read more
Introduction
Who You Are
The Linux Foundation
Linux Foundation Training
Certification Programs and Digital Badging
Linux Distributions
Preparing Your System
Things change in Linux
Documentation and Links
Preliminaries
Kernel Versions
Kernel Sources and Use of git
Hardware
How to Work in OSS Projects **
Stay Close to Mainline for Security and Quality
Study and Understand the Project DNA
Figure Out What Itch You Want to Scratch
Identify Maintainers and Their Work Flows and Methods
Get Early Input and Work in the Open
Contribute Incremental Bits, Not Large Code Dumps
Leave Your Ego at the Door: Don’t Be Thin-Skinned
Be Patient, Develop Long Term Relationships, Be Helpful
Cross-Development Toolchain
Built-in Linux Distribution Cross Compiler
Linaro
CodeSourcery
crosstool-ng
Buildroot
OpenEmbedded
Yocto Project
Labs
QEMU
Emulated Architectures
Image Formats
Why use QEMU?
Labs
Booting a Target Development Board from uSD
Getting SW onto a uSD card
Why is using uSD cards a bad idea?
Labs
Booting a Target Development Board over Ethernet
An easier way to develop
Objectives of the Lab
Labs
Kernel Configuration, Compilation, Booting
Labs
Device Drivers
Mechanism vs. Policy
Avoiding Binary Blobs
Power Management
How Applications Use Device Drivers
Walking Through a System Call Accessing a Device
Error Numbers
printk()
devres: Managed Device Resources
Labs
Modules and Device Drivers
Modules and Hot Plug
Labs
Memory Management and Allocation
Memory Zones
Page Tables
kmalloc()
__get_free_pages()
vmalloc()
Slabs and Cache Allocations
Labs
Character Devices
Major and Minor Numbers
Reserving Major/Minor Numbers
Accessing the Device Node
Registering the Device
udev
dev_printk() and Associates
file_operations Structure
Driver Entry Points
The file and inode Structures
Miscellaneous Character Drivers
Labs
Kernel Features
User-Space vs. Kernel-Space
What are System Calls?
Available System Calls
Scheduling Algorithms and Task Structures
Process Context
Labs
Transferring Between User and Kernel Space
put(get)_user() and copy_to(from)_user()
Direct Transfer: Kernel I/O and Memory Mapping
Kernel I/O
Mapping User Pages
Memory Mapping
User-Space Functions for mmap()
Driver Entry Point for mmap()
Accessing Files from the Kernel
Labs
Platform Drivers
Main Data Structures
Registering Platform Devices
An Example
Hardcoded Platform Data
The New Way: Device Trees
Labs
Device Trees
What Device Trees Do and What They Do Not Do
Device Tree Syntax
Device Tree Walk Through
Device Tree Bindings
Device Tree support in Boot Loaders
Using Device Tree Data in Drivers
Coexistence and Conversion of Old Drivers
Labs
Interrupts and Exceptions
Exceptions
Asynchronous Interrupts
MSI
Enabling/Disabling Interrupts
What You Cannot Do at Interrupt Time
IRQ Data Structures
Installing an Interrupt Handler
Labs
Timing Measurements
Jiffies
Getting the Current Time
Clock Sources
Real Time Clock
Programmable Interval Timer
Time Stamp Counter
HPET
Going Tickless
Kernel Timers
What are Kernel Timers?
Low Resolution Timer Functions
Low Resolution Timer Implementation
High Resolution Timers
Using High Resolution Timers
Labs
ioctls
Driver Entry point for ioctls
Defining ioctls
Labs
Unified Device Model and sysfs
Basic Structures
Real Devices
sysfs
kset and kobject examples
Labs
Firmware
Loading Firmware
Labs
Sleeping and Wait Queues
Going to Sleep and Waking Up
Going to Sleep Details
Exclusive Sleeping
Waking Up Details
Polling
Labs
Interrupt Handling: Deferrable Functions and User Drivers
Softirqs
Tasklets
Work Queues
New Work Queue API
Creating Kernel Threads
Threaded Interrupt Handlers
Interrupt Handling in User-Space
Labs
Hardware I/O
Allocating and Mapping I/O Memory
Accessing I/O Memory
Direct Memory Access (DMA)**
DMA Directly to User
DMA and Interrupts
DMA Memory Constraints
DMA Masks
DMA API
DMA Pools
Scatter/Gather Mappings
Labs
Memory Technology Devices (Flash Memory Filesystems)
NAND vs. NOR vs. eMMC
Driver and User Modules
Flash Filesystems
USB Drivers
USB Topology
Terminology
Endpoints
Descriptors
USB Device Classes
USB Support in Linux
Registering USB Device Drivers
Moving Data
Example of a USB Driver
Labs
Closing and Evaluation Survey
Appendices
—
Booting the Target Development Board from uSD
Labs
Kernel Architecture I
Monolithic and Micro Kernels
Object-Oriented Methods
Main Kernel Tasks
User-Space and Kernel-Space
Kernel Programming Preview
Memory Allocation
Transferring Data between User and Kernel Spaces
Linked Lists
Jiffies
Labs
Modules
A Trivial Example
Compiling Modules
Modules vs Built-in
Module Utilities
Automatic Loading/Unloading of Modules
Module Usage Count
Module Licensing
Exporting Symbols
Resolving Symbols **
Labs
Kernel Architecture II
Kernel Preemption
Real Time Preemption Patch
Labs
Kernel Configuration and Compilation
Kernel Browsers
Kernel Configuration Files
Kernel Building and Makefiles
initrd and initramfs
Labs
Kernel Style and General Considerations
Using Generic Kernel Routines and Methods
Making a Kernel Patch
sparse
Using likely() and unlikely()
Writing Portable Code, CPU, 32/64-bit, Endianness
Writing for SMP
Writing for High Memory Systems
Power Management
Keeping Security in Mind
Labs
Race Conditions and Synchronization Methods
Atomic Operations
Bit Operations
Spinlocks
Seqlocks
Disabling Preemption
Mutexes
Semaphores
Completion Functions
Read-Copy-Update (RCU)
Reference Counts
Labs
Memory Addressing
Systems With and Without MMU and the TLB
Memory Addresses
High and Low Memory
Memory Zones
Special Device Nodes
NUMA
Paging
Page Tables
page structure
Labs
Memory Allocation
Buddy System
Slabs and Cache Allocations
Memory Pools
kmalloc()
vmalloc()
Early Allocations and bootmem()
Memory Defragmentation
Labs
Prerequisites
Knowledge of basic kernel interfaces and methods such as how to write, compile, load and unload modules, use synchronization primitives, and the basics of memory allocation and management, such as is provided by LFD420 (Kernel Internals and Development). Pre-class preparation material will be provided before class.
Apr 2021
The instructor is obviously a professional, and he knew how to answer all our question perfectly. Moreover, the qemu emulations were great! It helped us a lot.
Apr 2021
The instructor was excellent! The labs are also very good, and the course book is well written as well.
Mar 2021
Instructor was great; went above and beyond by showing us examples in Linux that were not in the material.
Mar 2021
Good amount of depth; nice to break up the lecture with so many labs.
Nov 2020
Excellent course - greatly enjoyed my time taking the course, and did an excellent 'filling in the gaps' of my understanding.
Nov 2020
I definitely came away with a better understanding of Linux device drivers, and I'm hoping to be able to put some of that into practice soon. Many thanks to Behan for his time and expertise!
Nov 2020
It was a good overview, and we got to keep the PDF and physical book to do a deeper dive later.
Nov 2020
I liked the depth of knowledge of the instructor, being able to give further insight into topics beyond the printed course material. Further, the stories about how things have changed were very insightful, to get a better understanding of the process of how things have gotten to 'here".
Nov 2020
I really liked that the instructor was actually a major contributor to the linux kernel.
Nov 2020
The instructor was extremely knowledgeable, entertaining, and patient. I highly recommend Behan as an instructor in the future. He frequently was able to explain things in context, and provided real-world anecdotes that written material could never convey.
Nov 2020
I liked the labs, and forcing developers to write code helps with information retention.
Nov 2020
I liked the hands on lab work.
Nov 2020
The instructor really knows his work. Good guy all around.
Oct 2020
I appreciate having the labs interspersed with the coursework. The material is by its nature very dense, so being to able to break it up with
hands-on interaction is super useful.
Oct 2020
I like the lab exercises, and the low-level discussions with interfaces such as DMA, DTS, USB, etc.
Sep 2020
I liked the content and the very technical nature of the course. All the anecdotal knowledge Behan has about why things in Linux are the way they are helps my understanding.
Sep 2020
It is good to have the training material as a PDF. This is much more useful than printed papers as you can search for stuff.
Sep 2020
I liked the loads of hands-on, practical knowledge distilled throughout.
$3250
Jun, 21 - 24, 2021
9:00 am - 5:00 pm US/Central
Virtual, Instructor-Led
Jul, 26 - 29, 2021
9:00 am - 5:00 pm US/Central
Virtual, Instructor-Led
Aug, 30 - Sep, 2, 2021
9:00 am - 5:00 pm US/Central
Virtual, Instructor-Led
GUARANTEED With Next Enrollment
Classes will be guaranteed to run with next enrollment.
Dates don't work? Check out our partner schedule
Live Online (Virtual)
4 days of Instructor-led class time
Hands-on Labs & Assignments
Resources & Course Manual
Certificate of Completion
Digital Badge
