Book Image

Linux Device Drivers Development

By : John Madieu

Book Image

Linux Device Drivers Development

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

What this book covers

What you need for this book

Who this book is for

Reader feedback

Customer support

Free Chapter

Introduction to Kernel Development

Introduction to Kernel Development

Environment setup

Device Driver Basis

Device Driver Basis

User space and kernel space

Driver skeletons

Errors and message printing

Module parameters

Building your first module

Kernel Facilities and Helper Functions

Kernel Facilities and Helper Functions

Understanding the container_of macro

Kernel sleeping mechanism

Delay and timer management

Kernel locking mechanism

Work deferring mechanism

Kernel interruption mechanism

Invoking user space applications from the kernel

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

Platform Device Drivers

Platform Device Drivers

Platform drivers

Platform devices

Devices, drivers, and bus matching

The Concept of Device Tree

The Concept of Device Tree

Device tree mechanism

Representing and addressing devices

Handling resources

Platform drivers and DT

I2C Client Drivers

I2C Client Drivers

The driver architecture

Accessing the client

I2C and the device tree

SPI Device Drivers

SPI Device Drivers

The driver architecture

Accessing and talking to the client

Putting it all together

SPI user mode driver

Regmap API – A Register Map Abstraction

Regmap API – A Register Map Abstraction

Programming with the regmap API

IIO Framework

IIO data structures

Triggered buffer support

IIO data access

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

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)

The Linux Device Model

The Linux Device Model

LDM data structures

Deep inside LDM

The device model and sysfs

Pin Control and GPIO Subsystem

Pin Control and GPIO Subsystem

Pin control subsystem

The GPIO subsystem

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

Advanced IRQ Management

Advanced IRQ Management

Multiplexing interrupts and interrupt controllers

Advanced peripheral IRQs management

Interrupt request and propagation

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

RTC Drivers

RTC framework data structures

RTCs and user space

PWM Drivers

PWM controller driver

PWM consumer interface

Using PWMs with the sysfs interface

Regulator Framework

Regulator Framework

PMIC/producer driver interface

Regulators consumer interface

Regulator binding

Framebuffer Drivers

Framebuffer Drivers

Driver data structures

Framebuffer from user space

Network Interface Card Drivers

Network Interface Card Drivers

Driver data structures

The device methods

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Generating and reporting an input event

Device allocation and registration are essential, but they are not the main goal of an input device driver, which is designed to report even to the input core. Depending on the type of event your device can support, the kernel provides appropriate APIs to report them to the core.

Given an EV_XXX capable device, the corresponding report function would be input_report_xxx(). The following table shows a mapping between the most important event types and their report functions:

Event type	Report function	Code example
`EV_KEY`	`input_report_key()`	`input_report_key(poll_dev->input, BTN_0, gpiod_get_value(ms-> reset_btn_desc) & 1)`;
`EV_REL`	`input_report_rel()`	`input_report_rel(nunchuk->input, REL_X, (nunchuk->report.joy_x - 128)/10)`;
`EV_ABS`	`input_report_abs()`	`input_report_abs(bma150->input, ABS_X, x_value...`