Sign In Start Free Trial

Linux Device Drivers Development

By : John Madieu

4 (30)

Linux Device Drivers Development

4 (30)

By: John Madieu

Overview of this book

Linux kernel is a complex, portable, modular and widely used piece of software, running on around 80% of servers and embedded systems in more than half of devices throughout the World. Device drivers play a critical role in how well a Linux system performs. As Linux has turned out to be one of the most popular operating systems used, the interest in developing proprietary device drivers is also increasing steadily. This book will initially help you understand the basics of drivers as well as prepare for the long journey through the Linux Kernel. This book then covers drivers development based on various Linux subsystems such as memory management, PWM, RTC, IIO, IRQ management, and so on. The book also offers a practical approach on direct memory access and network device drivers. By the end of this book, you will be comfortable with the concept of device driver development and will be in a position to write any device driver from scratch using the latest kernel version (v4.13 at the time of writing this book).

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

Introduction to Kernel Development

Introduction to Kernel Development

Environment setup

Kernel habits

Summary

Device Driver Basis

Device Driver Basis

User space and kernel space

Driver skeletons

Errors and message printing

Module parameters

Building your first module

Summary

Kernel Facilities and Helper Functions

Kernel Facilities and Helper Functions

Understanding the container_of macro

Linked lists

Kernel sleeping mechanism

Delay and timer management

Kernel locking mechanism

Work deferring mechanism

Kernel interruption mechanism

Threaded IRQs

Invoking user space applications from the kernel

Summary

Character Device Drivers

Character Device Drivers

The concept behind major and minor

Introduction to device file operations

Allocating and registering a character device

Writing file operations

Summary

Platform Device Drivers

Platform Device Drivers

Platform drivers

Platform devices

Devices, drivers, and bus matching

Summary

The Concept of Device Tree

The Concept of Device Tree

Device tree mechanism

Representing and addressing devices

Handling resources

Platform drivers and DT

Summary

I2C Client Drivers

I2C Client Drivers

The driver architecture

Accessing the client

I2C and the device tree

Summary

SPI Device Drivers

SPI Device Drivers

The driver architecture

Accessing and talking to the client

Putting it all together

SPI user mode driver

Summary

Regmap API – A Register Map Abstraction

Regmap API – A Register Map Abstraction

Programming with the regmap API

Summary

IIO Framework

IIO Framework

IIO data structures

Triggered buffer support

IIO data access

IIO tools

Summary

Kernel Memory Management

Kernel Memory Management

System memory layout - kernel space and user space

Address translation and MMU

Memory allocation mechanism

Work with I/O memory to talk with hardware

Memory (re)mapping

Linux caching system

Device-managed resources – Devres

Summary

DMA – Direct Memory Access

DMA – Direct Memory Access

Setting up DMA mappings

The concept of completion

The DMA engine API

Putting it all together – NXP SDMA (i.MX6)

DMA DT binding

Summary

The Linux Device Model

The Linux Device Model

LDM data structures

Deep inside LDM

The device model and sysfs

Summary

Pin Control and GPIO Subsystem

Pin Control and GPIO Subsystem

Pin control subsystem

The GPIO subsystem

Summary

GPIO Controller Drivers – gpio_chip

GPIO Controller Drivers – gpio_chip

Driver architecture and data structures

Pin controller guidelines

Sysfs interface for GPIO controller

GPIO controllers and the DT

Summary

Advanced IRQ Management

Advanced IRQ Management

Multiplexing interrupts and interrupt controllers

Advanced peripheral IRQs management

Interrupt request and propagation

Summary

Input Devices Drivers

Input Devices Drivers

Input device structures

Allocating and registering an input device

Generating and reporting an input event

User space interface

Putting it all together

Summary

RTC Drivers

RTC Drivers

RTC framework data structures

RTCs and user space

Summary

PWM Drivers

PWM Drivers

PWM controller driver

PWM consumer interface

Using PWMs with the sysfs interface

Summary

Regulator Framework

Regulator Framework

PMIC/producer driver interface

Regulators consumer interface

Regulator binding

Summary

Framebuffer Drivers

Framebuffer Drivers

Driver data structures

Device methods

Driver methods

Framebuffer from user space

Summary

Network Interface Card Drivers

Network Interface Card Drivers

Driver data structures

The device methods

Driver methods

Summary

Customer Reviews

4 (30)

5 star

56.7%

4 star

10%

3 star

16.7%

2 star

10%

1 star

6.7%

Deep inside LDM

Under the hood, the LDM relies on three important structures, which are kobject, kobj_type, and kset. Let us see how each of these structures are involved in the device model.

kobject structure

kobject is the core of the device model, running behind the scenes. It brings an OO-like programming style to the kernel, and is mainly used for reference counting and to expose devices hierarchies and relationships between them. kobjects introduce the concept of encapsulation of common object properties, such as usage reference counts:

struct kobject { 
    const char *name; 
    struct list_head entry; 
    struct kobject *parent; 
    struct kset *kset; 
    struct kobj_type *ktype; 
    struct sysfs_dirent *sd; ...

Search

Your notes and bookmarks