GoGo Training – Linux Device Drivers: Programming at the Kernel Level

This Linux online training course introduces Linux device drivers and shows how they interact with the Linux kernel. Numerous programming exercises reveal the rich set of kernel APIs that provide a multitude of services to driver programmers. This training teaches you how Linux handles asynchronous I/O in a way that is totally transparent to applications. You’ll examine the unique problems of debugging in Kernel space. Perhaps most important, you’ll see how much of a device driver involves interactions with the kernel that have nothing to do with accessing physical hardware. Although the exercises are carried out on a PC, much of the code is easily ported to other architectures supported by Linux.
Objectives

As a result of taking this Linux device driver course, you will be able to:

Describe the four types of devices and their properties
Design, program, and debug kernel loadable modules

OutLine:
======

Module 00: Linux Device Drivers: Programming at the Kernel Level Online Training – Course Introduction

Module 01: So What’s a Device Driver?

Why device drivers
User space I/O APIs
Four types of devices
The /dev directory

Module 02: Kernel Loadable Modules

What is a kernel loadable module?
Module utilities
A module example
Kernel modules and the GPL

Module 03: Basic Character Driver

Registering and initializing a driver
The file operations table, fops
Driver example
Mutual exclusion, the semaphore

Module 04: Debugging Kernel Code

printk()
strace
The /proc file system
ioctl()
kgdb

Module 05: Blocking I/O

The wait queue
Putting a process to sleep
Blocking example
The seq file interface
Poll and select
Asynchronous notification

Module 06: Accessing Hardware

Side effects and compiler optimization
I/O APIs
The hardware
Driver example
Barriers
Accessing hardware from User Space

Module 07: Handling Interrupts

Interrupt context
Registering an interrupt handler, the IRQ flags
Interrupt example
Probing for the interrupt source
The bottom half – tasklets and workqueues

Module 08: Memory Allocation

kmalloc() and kfree()
kmalloc() flags
get_free_pages()
vmalloc()

Module 09: Time

jiffies
Implementing time delays – example
Timers
Current time

Module 10: Block Drivers

The block subsystem
Device registration
The request queue and function
Block driver example

Module 11: Network Drivers

Device registration
The socket buffer
Driver example – “snull”
NAPI – the “new” API

Module 12: PCI Drivers

PCI addressing and bridging
Accessing configuration space
PCI data structures and macros
modules.pcimap
Sample PCI driver

Module 13: USB Drivers

USB structure and characteristics
Device classes
USB data structures and macros
USB Request Block, URB
Sample USB driver

Module 14: Linux Driver Model

Power Management and Shutdown
User Space Communication
Hot Pug
Device Classes

Module 15: Integrating a Driver with the Kernel Source Tree

Configuring and building the kernel
The config. file
Source code mods
Kconfig files