Embedded Linux Customization and Driver Development

Course Overview

Course Length:

3 Days

CEUs:

2.0

Format:

Hands-on/Lecture

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:

Syllabus

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

Introduction

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.