Book Image

Linux Device Driver Development - Second Edition

By : John Madieu
Book Image

Linux Device Driver Development - Second Edition

By: John Madieu

Overview of this book

Linux is by far the most-used kernel on embedded systems. Thanks to its subsystems, the Linux kernel supports almost all of the application fields in the industrial world. This updated second edition of Linux Device Driver Development is a comprehensive introduction to the Linux kernel world and the different subsystems that it is made of, and will be useful for embedded developers from any discipline. You'll learn how to configure, tailor, and build the Linux kernel. Filled with real-world examples, the book covers each of the most-used subsystems in the embedded domains such as GPIO, direct memory access, interrupt management, and I2C/SPI device drivers. This book will show you how Linux abstracts each device from a hardware point of view and how a device is bound to its driver(s). You’ll also see how interrupts are propagated in the system as the book covers the interrupt processing mechanisms in-depth and describes every kernel structure and API involved. This new edition also addresses how not to write device drivers using user space libraries for GPIO clients, I2C, and SPI drivers. By the end of this Linux book, you’ll be able to write device drivers for most of the embedded devices out there.

Related Content you might be interested in

Current Title:

Small book image
Linux Device Driver Development - Second Edition
John Madieu
Apr, 2022 | 708 pages
Small book image
Mastering Linux Device Driver Development
John Madieu
Jan, 2021 | 646 pages
Small book image
Linux Device Driver Development Cookbook
Rodolfo Giometti
May, 2019 | 356 pages
Small book image
Mastering Linux Kernel Development
CH Raghav Maruthi
Oct, 2017 | 354 pages
Table of Contents (23 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Share Your Thoughts
1
Section 1 -Linux Kernel Development Basics
Section 1 -Linux Kernel Development Basics
Free Chapter
2
Chapter 1: Introduction to Kernel Development
Chapter 1: Introduction to Kernel Development
Setting up the development environment
Configuring and building the Linux kernel
Building and installing modules
Summary
3
Chapter 2: Understanding Linux Kernel Module Basic Concepts
Chapter 2: Understanding Linux Kernel Module Basic Concepts
An introduction to the concept of modules
Building a Linux kernel module
Handling module parameters
Dealing with symbol exports and module dependencies
Learning some Linux kernel programming tips
Summary
4
Chapter 3: Dealing with Kernel Core Helpers
Chapter 3: Dealing with Kernel Core Helpers
Linux kernel locking mechanisms and shared resources
Dealing with kernel waiting, sleeping, and delay mechanisms
Understanding Linux kernel time management
Implementing work-deferring mechanisms
Kernel interrupt handling
Summary
5
Chapter 4: Writing Character Device Drivers
Chapter 4: Writing Character Device Drivers
The concept of major and minor
Character device data structure introduction
Creating a device node
Implementing file operations
Summary
6
Section 2 - Linux Kernel Platform Abstraction and Device Drivers
Section 2 - Linux Kernel Platform Abstraction and Device Drivers
7
Chapter 5: Understanding and Leveraging the Device Tree
Chapter 5: Understanding and Leveraging the Device Tree
Understanding the basic concept of the device tree mechanism
Representing and addressing devices
Handling resources
Summary
8
Chapter 6: Introduction to Devices, Drivers, and Platform Abstraction
Chapter 6: Introduction to Devices, Drivers, and Platform Abstraction
Linux kernel platform abstraction and data structures
Device and driver matching mechanism explained
Summary
9
Chapter 7: Understanding the Concept of Platform Devices and Drivers
Chapter 7: Understanding the Concept of Platform Devices and Drivers
Understanding the platform core abstraction in the Linux kernel
Dealing with platform devices
Platform driver abstraction and architecture
Example of writing a platform driver from scratch
Summary
10
Chapter 8: Writing I2C Device Drivers
Chapter 8: Writing I2C Device Drivers
I2C framework abstractions in the Linux kernel
The I2C driver abstraction and architecture
How not to write I2C device drivers
Summary
11
Chapter 9: Writing SPI Device Drivers
Chapter 9: Writing SPI Device Drivers
Understanding the SPI framework abstractions in the Linux kernel
Dealing with the SPI driver abstraction and architecture
Learning how not to write SPI device drivers
Summary
12
Section 3 - Making the Most out of Your Hardware
Section 3 - Making the Most out of Your Hardware
13
Chapter 10: Understanding the Linux Kernel Memory Allocation
Chapter 10: Understanding the Linux Kernel Memory Allocation
An introduction to Linux kernel memory-related terms
Demystifying address translation and MMU
Working with I/O memory to talk to hardware
Memory (re)mapping
Summary
14
Chapter 11: Implementing Direct Memory Access (DMA) Support
Chapter 11: Implementing Direct Memory Access (DMA) Support
Setting up DMA mappings
Introduction to the concept of completion
Working with the DMA engine's API
Putting it all together – Single-buffer DMA mapping
A word on cyclic DMA
Understanding DMA and DT bindings
Summary
15
Chapter 12: Abstracting Memory Access – Introduction to the Regmap API: a Register Map Abstraction
Chapter 12: Abstracting Memory Access – Introduction to the Regmap API: a Register Map Abstraction
Introduction to the Regmap data structures
Handling Regmap initialization
Using Regmap register access functions
Regmap-based SPI driver example – putting it all together
Leveraging Regmap from the user space
Summary
16
Chapter 13: Demystifying the Kernel IRQ Framework
Chapter 13: Demystifying the Kernel IRQ Framework
Brief presentation of interrupts
Understanding interrupt controllers and interrupt multiplexing
Diving into advanced peripheral IRQ management
Demystifying per-CPU interrupts
Summary
17
Chapter 14: Introduction to the Linux Device Model
Chapter 14: Introduction to the Linux Device Model
Introduction to LDM data structures
Getting deeper inside LDM
Overview of the device model from sysfs
Summary
18
Section 4 - Misc Kernel Subsystems for the Embedded World
Section 4 - Misc Kernel Subsystems for the Embedded World
19
Chapter 15: Digging into the IIO Framework
Chapter 15: Digging into the IIO Framework
Introduction to IIO data structures
Integrating IIO triggered buffer support
Accessing IIO data
Dealing with the in-kernel IIO consumer interface
Writing user-space IIO applications
Walking through user-space IIO tools
Summary
20
Chapter 16: Getting the Most Out of the Pin Controller and GPIO Subsystems
Chapter 16: Getting the Most Out of the Pin Controller and GPIO Subsystems
Introduction to some hardware terms
Introduction to the pin control subsystem
Dealing with the GPIO controller interface
Getting the most out of the GPIO consumer interface
Learning how not to write GPIO client drivers
Summary
21
Chapter 17: Leveraging the Linux Kernel Input Subsystem
Chapter 17: Leveraging the Linux Kernel Input Subsystem
Introduction to the Linux kernel input subsystem – its data structures and APIs
Allocating and registering an input device
Using polled input devices
Generating and reporting input events
Handling input devices from the user space
Summary
Why subscribe?
22
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Share Your Thoughts

Working with the DMA engine's API

The DMA engine is a generic kernel framework used to develop DMA controller drivers and leverage this controller from the consumer side. Through this framework, the DMA controller driver exposes a set of channels that can be used by client devices. This framework then makes it possible for client drivers (also called slaves) to request and use DMA channels from the controller to issue DMA transfers.

The following diagram is the layering, showing how this framework is integrated with the Linux kernel:

Figure 11.2 – DMA engine framework

Here we will simply walk through that (slave) API, which is applicable for slave DMA usage only. The mandatory header here is as follows:

#include <linux/dmaengine.h>

The slave DMA usage is straightforward, and consists of the following steps:

  1. Informing the kernel about the device's DMA addressing capabilities.
  2. Requesting a DMA channel.
  3. If successful...
Previous Section
End of Section 4
Next Section