Linux Device Drivers: Kernel Level Programming Special Offer! Linux Device Driver Course ONLY $395 (List Price $545)

Course Description

Welcome to Linux Device Drivers: Programming at the Kernel Level with Doug Abbott.  If you are ready to learn with the experts, then this course is for you.  Doug has over 20 years’ experience working on the operating system and device driver level with emphasis on embedded Linux applications and is here to answer your questions.

Working with Doug you will become a master Linux programmer at the Device Driver level and be able to:

• Understand how device drivers interact with the Linux kernel 
• Work with the rich set of kernel APIs that provide a multitude of services to driver programmers.  
• See how Linux handles asynchronous I/O in a way that is totally transparent to applications.  
• Examine the unique problems of debugging in Kernel space.  
• Understand how much of a device driver involves interactions with the kernel that have nothing to do with accessing physical hardware. 

While taking this course you will have access to Doug’s video lectures, demos and hands on exercises where you will have ample opportunity to practice what you’ve learned. Most of the lab exercises run on a standard PC. Nevertheless, the code is easily ported to other architectures supported by Linux. 

The hands-on exercises can be done using any version of the Linux Kernel.  Because the Linux Kernel changes frequently we are here to support any questions you may have on the course exercises and solutions while you take the course.

Some of the exercise are hardware dependent and require either a parallel printer port, if your computer has one, or you can purchase a single board computer to use to do the exercises – see purchase options section below.
 

In This Course You Will Learn:

• Create and build kernel loadable modules
• Understand the four types of devices and their properties
• Determine how device drivers interact with the Linux kernel
• Use techniques for debugging kernel-level code
• Access peripheral hardware
• Manage Asynchronous interrupts

Prerequisites

To successfully complete this course you will need to be proficient in C programming and Linux Essentials or have taken C Programming Bootcamp Part 1, C Programming Bootcamp Part 2 and Linux Essentials. 

You will need a PC running a fairly recent Linux distribution such as CentOS 7.  To complete the hardware-based exercises in modules 7 to 10 you will need either a standard 25-pin parallel port or a small single board computer with general purpose I/O ports. You can purchase a single board computer with your course below or directly from the instructor at www.intellimetrix.us/gogotraining.  If your laptop lacks a parallel port, a compatible docking station usually has one.
 

Outline

Module 00: Linux Device Drivers 2013: Programming at the Kernel Level - Course Introduction

Module 01: So what’s a Device Driver?

• Why device drivers
• User space I/O APIs
• Three types of devices
• The /dev directory
• Demo: The /dev directory
• Exercise: Examine the /dev directory

Module 02: Kernel Loadable Modules

• What is a kernel loadable module?
• Module utilities
• Modules are kernel version specific
• Demo: A module example
• Kernel modules and the GPL
• Exercise:  Loading a module

Module 03: Basic Character Driver

• Registering and initializing a Driver
• The file operations table, fops
• Demo:  The Driver Example
• Exercise:  Running a Basic Character Driver
• Mutual Exclusion, the mutex
• Demo:  The mutex code

Module 04: Debugging Kernel Code

• printk()
• strace
• The /proc file system
• Demo: proc file review
• Exercise: List the proc file
• ioctl()
• Demo: ioctl Code Review
• Exercise: Execute ioctl commands
• Kgdb

Module 05: Blocking I/O Part 1

• The wait queue
• Putting a process to sleep
• The device model and sysfs
• Demo: Blocking example
• Build and Run Blocking
• Exercise: Run a blocking device driver
• Exercise: Find the Bug

Module 06: Blocking I/O Part 2

• The seq file interface
• Demo: The seq file system
• Exercise: List a proc file
• Poll and select
• Demo: the poll method
• Asynchronous notification
• Demo: Code review
• Exercise: Using asynchronous notification

Module 07: Accessing Hardware Part 1

• Side effects and compiler optimization
• I/O APIs
• The hardware
• Demo: Code review of hardware access on an single board computer
• Exercise: Flash the LEDs

Module 08: Accessing Hardware Part 2

• Hardware and BIOS
• Demo: Code review of hardware access on a parallel printer port 
• Exercise: Flash the LEDs
• Advanced Exercise: Shell Script for Alternating 2 LEDs
• Barriers
• Accessing hardware from User Space
• Demo: Code Review of accessing hardware from UserSpace
• Exercise: Accessing hardware from UserSpace

Module 09: Handling Interrupts Part 1

• Interrupt context
• Registering an interrupt handler, the IRQ flags
• Demo: interrupt example
• Exercise: Execute Interrupt driver
• Probing for the interrupt source
• Exercise: Interrupt probing

Module 10: Handling Interrupts Part 2

• Deferred Interrupt – tasklets and workqueues
• Demo: Deferred Interrupt
• Exercise:  Deferred interrupt processing
• Simple_int with Bottom Half
• Advanced Exercise: Using simple_int

Module 11: Memory allocation

• kmalloc() and kfree()
• kmalloc() flags
• The slab allocator
• Demo: Slab allocator tools
• Exercise: Slab allocator tools
• get_free_pages()
• The buddy algorithm
• Demo: The buddy info proc file
• Exercise: The buddy info proc file
• vmalloc()

Module 12: Managing Time

• jiffies
• Current time
• Demo: Implementing time delays
• Exercise: Implementing time delays
• The timer callback
• Demo: Using timer callbacks
• Exercise: Using timer callbacks

Module 13: Synchronization

• Semaphores
• Spinlocks
• Mutexes

Module 14: Block Drivers

• The block subsystem
• I/O schedulers
• Device registration
• The request queue and function
• Demo: Block driver example
• Exercise: Build and Try a Block Driver

Module 15: Network Drivers

• Device registration
• The socket buffer
• Demo: Driver example – “snull”
• Exercise: A network driver
• NAPI – the “new” API
• Demo:  NAPI
• Exercise: A NAPI network driver

Module 16: PCI Drivers

• PCI addressing and bridging
• Demo: PCI tools
• Exercise: Using PCI tools
• Accessing configuration space
• PCI data structures and macros
• modules.pcimap
• Demo: Sample PCI driver

Module 17: USB Drivers

• USB structure and characteristics (put after slide 3)
• Demo: USB Tools
• Exercise: Using USB tools
• Device classes
• USB data structures and macros
• USB Request Block, URB
• Demo: Sample USB driver

Module 18: Linux Driver Model

• Overview, motivation
• kobject
• sysfs
• Demo: Using sysfs
• Exercise: Using sysfs
• Module parameters in sysfs
• Demo: Module parameters in sysfs
• Exercise: Module parameters in sysfs

Module 19: Integrating a Driver with the Kernel Source Tree

• Configuring and building the kernel
• The Kernel source tree
• Demo: Review of kernel source tree
• Exercise: Examine directories of kernel source code
• Xconfig
• Demo: Using xconfig
• Exercise: Using xconfig
• The .config file
• Source code mods
• Kconfig files
• Demo: Kconfig files
• Exercise: Examine Kconfig files