Course Overview

Course Length: 
3 Days

Whether you are developing Linux device drivers for unsupported peripherals or writing a board support package (BSP) to port the operating system to custom embedded hardware, there's a steep learning curve. Through a mix of lectures and hands-on programming exercises on real hardware, this course will help you quickly move on to developing your own Linux driver code. Major topics include the Linux driver model and device frameworks, debugging tools and techniques, as well as hardware initialization and interfacing, interrupt support, multithreading, and synchronization.

Attendees will complete approximately half a dozen hands-on exercises on an ARM board that they will be able to keep when the course is over.

Topics covered during this course include:

  • Introduction to Embedded Linux
    • Linux Kernel Architecture
    • Linux Bootloader Configuration and Customization
    • Linux Kernel Configuration and Customization
    • Creating A Linux Root Filesystem Using BusyBox 
  • Linux Device Drivers
    • Loadable Kernel Modules
    • Linux Device Model
    • Linux Bus Devices
    • Linux Class Devices
    • Accessing Hardware Using MMIO
    • Kernel Interrupts, Multithreading, and Synchronization

This course is appropriate for:

  • Embedded software developers learning to write drivers for Linux (or Android)
  • Embedded software developers responsible for porting Linux to custom hardware

Prerequisites:  Attendees should have prior programming experience in the C programming language.

Explore this course:

Find out more:


The following is a summary of the major course topics and should not be considered the section-by-subsection lecture breakdown.


  • Linux Kit Overview
  • ARM Dev Kit Introduction and Setup
  • GNU Toolchain Introduction
  • Building and Deploying U-Boot
  • Debugging Options

Hardware Interfacing And Bootloader Customization

  • Intro to Embedded Hardware
  • Intro to ARM SoC Architecture
  • Intro to Peripheral Controllers
  • Intro to GPIOs
  • U-Boot Architecture

Intro To The Linux Kernel 

  • Software Frameworks
  • Linux Kernel Architectural
  • ARM Linux Boot Process
  • ARM Linux Machine-Specific Initializations
  • Building, Deploying and Testing The Linux Kernel
  • Configuring and Building BusyBox
  • Creating Root Filesystem FHS Directories
  • Creating Root Filesystem Configuration Files And Scripts
  • Deploying and Testing a Linux Root Filesystem

Advanced The Linux Kernel Architecture

  • Kernel System Calls
  • Kernel Scheduler and Multithreading
  • ARM Memory Mapped Units
  • Linux Kernel Debugging
  • ARM Kernel Board-Specific Initialization
  • Intro to Platform Bus Devices

Loadable Kernel Modules

  • Introduction to Kernel Modules
  • Kernel Module Framework and Lifecycle
  • GNU Makefiles
  • Building an LKM Out-Of-Tree
  • Loading and Testing LKMs

Linux Bus Devices

  • Sysfs and the Linux Device Model
  • Sysfs Attributes
  • Bus Devices and Frameworks
  • Bus Device Drivers

Accessing MMIO Hardware

  • Getting Cookies For PCI and MMIO Devices
  • Accessing Peripheral Controller Registers Using Cookies

Linux Class Devices

  • Linux Devices Classes Frameworks
  • Creating Class Devices
  • Misc Device Class
  • Supporting open(), close(), read(), write()
  • Passing Data Between Kernel and User-Space
  • Supporting IOCTL calls

Kernel Interrupts, Multithreading, And Synchronization

  • Interrupt Handling
  • Kernel Threads
  • Waiting / Sleeping
  • Kernel Workqueues
  • Concurrent Access
  • Atomic Variables
  • Critical Sections

Related Courses

Find out More

Contact us now to find out more about this course or to enquire about an on-site training at your company.

Recording Policy

Barr Group's courses may not be audiotaped, videotaped, or photographed without consent from Barr Group's executive team.