Linux嵌入式处理器驱动开发指南：实战教程

需积分: 0 197 浏览量更新于2024-07-18 收藏 6.51MB PDF 举报

"《Linux嵌入式处理器驱动设计》是一本专门针对开发驱动程序人员编写的指南，由Alberto Liberal delos Ríos所著，版权归其所有。该书于2018年出版，深入讲解了如何在Linux环境下进行嵌入式处理器的驱动开发。Linux作为注册商标，被Linus Torvalds持有，书中提及的其他商标则属于各自的产权人。本书的核心内容涵盖了Linux内核模块的开发实践，特别强调了遵循GPL（GNU通用公共许可证）的重要性。GPL是一种开源协议，它赋予用户自由使用、研究、修改和共享软件的权利，同时规定，当软件被重新分发或修改时，必须同样以GPL的方式发布，并附带源代码，以确保开源精神的延续。作者Alberto Liberal delos Ríos是一位拥有超过15年嵌入式系统经验的现场应用工程师，在Arrow Electronics工作，他的专业背景使得本书内容具有实战性和深度。书中不仅提供理论知识，还包含实际的kernel模块示例，这些示例是按照GPL许可发布的，旨在帮助读者掌握Linux驱动开发的技巧和最佳实践。本书的出版由Alberto Liberal delos Ríos个人独立完成，包括图形设计部分由Signo Comunicación Consultores SLU负责。整本书适合那些希望在Linux嵌入式领域深入学习并实践驱动开发的工程师们，无论是在学习阶段还是在项目实施中，都能从中获益良多。通过阅读这本书，读者将能够提升自己的技术能力，适应快速发展的嵌入式Linux技术环境。"

Preface

[ 14 ]

In Device Tree Linux systems the device drivers are loaded by the kernel when the device is

declared in the Device Tree. The driver retrieves the conguration data from the DT node (e.g, the

physical addresses allocated to the device, which interrupt(s) the device triggers, and also device

specic information). Throughout this book, you will see the important role of the Device Tree for

the development of your Linux device drivers and it will be consequently explained in detail.

This book will teach you how to develop device drivers for Device Tree Linux embedded systems.

You will learn how to write dierent types of Linux drivers as well as the appropriate APIs

(Application Program Interfaces) and methods to interface with kernel and user spaces. This is a

book is meant to be practical, but also provides an important theoretical base. More than twenty

drivers are wrien and ported to three dierent processors. You can choose between NXP i.MX7D,

Microchip SAMA5D2 and Broadcom BCM2837 processors to develop your drivers. You can use

any of these processor boards while it has available some GPIOs, a SPI controller and an I2C

controller. I encourage you to acquire one of these boards before you start with the reading, as the

content of this book is eminently practical and reproducing the labs with the board will help you

to x the theoretical content exposed throughout the book.

You will learn how to develop drivers, from the simplest ones that do not interact with any

external hardware, to drivers that manage dierent kind of devices: accelerometers, DACs, ADCs,

RGB LEDs, Multidisplay LED controllers, I/O expanders, and Buons. You will also develop DMA

drivers, drivers that manage interrupts, and drivers that write/read on the internal registers of

the processor to control external devices. To easy the development of some of these drivers, you

will use dierent types of Frameworks: Misc framework, LED framework, UIO framework, Input

framework and the IIO industrial one.

This book is a learning tool to start developing drivers without any previous knowledge about

this eld, so the intention during its writing has been to develop drivers without a high level of

complexity that both serve to reinforce the main driver development concepts and can be a starting

point to help you to develop your own drivers. And, remember that the best way to develop a

driver is not to write it from scratch. You can reuse free code from similar Linux kernel mainline

drivers. All the drivers wrien throughout this book are GPL licensed, so you can modify and

redistribute them under the same license.

[ 15 ]

Preface

[ 15 ]

Who is this Book for?

This book is ideal for Linux embedded application developers that want to know how to develop

drivers from scratch. It is also indicated for embedded software developers that have developed

drivers for non-Device Tree kernels and want to learn how to create new Device Tree-based ones.

And nally, it is for students and hobbyists that want to learn how to deal with the low level

hardware of embedded platforms using Linux. Before reading this book, having prior, basic

knowledge of C language, Linux embedded and Yocto Project tools would be helpful, though not

mandatory.

How this Book is Structured

Chapter 1, Building the System, starts by describing the main parts of an Embedded Linux system

and the dierent ways to build it, explaining why the Yocto Project and Debian were chosen as

your build options. Next, it describes in detail how to build a Linux embedded image using Yocto

and Debian and how to compile Linux kernel outside Yocto. The generated Linux image will be

used for the development of drivers and applications throughout the book. Finally, this chapter

describes how to congure the free Eclipse IDE to develop the drivers.

Chapter 2, The Linux Device and Drivel Model, explains the relationship between "Bus" drivers,

"Bus controller" drivers and "Device" drivers. It also provides an introduction to the Device Tree.

Chapter 3, The Simplest Drivers, covers several simple drivers that are not yet interacting

with user applications through "system calls". You will use the Eclipse IDE to create, compile

and deploy the drivers in your target board. This chapter will let you check that your driver

development ecosystem is working properly.

Chapter 4, Character Drivers, describes the architecture of the character drivers. It explains

how driver´s operations are called from user space using system calls and how to exchange

data between the kernel and user spaces. It also explains how to identify and create each Linux

device. Several drivers will be wrien that exchange information with the user space using

dierent methods for the creation of the device nodes. The rst driver developed will use the

traditionally static device creation method using the "mknod" command, the second one will show

how to create device les with "devtmpfs" and the last one will create the device les using the

"miscellaneous framework". This chapter also explains how to create a device class, and a device

driver entry under the sysfs.

Chapter 5, Platform Drivers, describes what a platform driver is, how a platform device is

statically described in the Device Tree, and the process of associating the device with the device

driver, called "binding". In this chapter, you will develop your rst driver interacting with the

hardware. Before developing the driver, a detailed explanation will be provided on the way the

Preface

[ 16 ]

pads of your target processor can be multiplexed to dierent functions and how to select the

required muxing option within the Device Tree. This chapter also describes the Pinctrl Subsystem

and the new GPIO Descriptor Consumer Interface. You will develop drivers that control external

devices mapping of peripheral addresses from physical to virtual and writing/reading to/from

these virtual addresses within kernel space. You will also learn to write drivers that control LEDs

using the Linux LED subsystem. Finally, this chapter explains how to develop an user space driver

using the UIO framework.

Chapter 6, I2C Client Drivers, describes the Linux I2C subsystem, which is based in the Linux

device model. You will learn to declare Device Tree I2C devices and will develop several I2C client

drivers throughout this chapter. You will also see how to add "sysfs" support to a platform driver

to control the hardware via sysfs entries.

Chapter 7, Handling Interrupts in Platform Drivers, introduces interrupt hardware and software

operation in Linux embedded processors, explaining how the interrupt controllers and the

interrupt-capable peripheral nodes are linked in the Device Tree. You will develop drivers that

manage interrupts from external hardware. You will learn about deferred work kernel facilities

that allows one to schedule code to be executed at a later time. This scheduled code can run either

in process context using "workqueues" or "threaded interrupts", or in interrupt context using

"softirqs", "tasklets" and "timers". Finally, this chapter shows how an user application is put to

sleep using a "wait queue" and woken up later via an interrupt.

Chapter 8, Memory Management Drivers, explains the MMU (Memory Management Unit), and

the dierent types of addresses used in Linux. Finally, this chapter describes the dierent kernel

memory allocators.

Chapter 8, DMA Drivers, describes the "Linux DMA Engine Subsystem", and the dierent types

of DMA mappings. Several drivers are developed that manage memory to memory transactions

without CPU intervention, using DMA scather/gather mappings and DMA from user space using

the mmap() system call.

Chapter 10, Input Subsystem Framework for Device Drivers, introduces the use of frameworks

to provide a coherent user space interface for every type of device, regardless of the drivers. The

chapter explains in the relationship between the physical and logical parts of a driver that uses a

kernel framework. It focus on the Input subsystem framework, that takes care of the input events

coming from the human user. This chapter also describes the Linux SPI subsystem, which is based

in the Linux device model. You will learn how to declare Device Tree SPI devices and will develop

a SPI client driver using the Input framework. Finally, this chapter explains how to interact from

user space with the I2C bus using the "i2c-tools" applications.

Chapter 11, Industrial I/O Subsystem for Device Drivers, describes the IIO (Linux Industrial I/O

Subsystem). The IIO subsystem provides support for ADCs, DACs, gyroscopes, accelerometers,

[ 17 ]

Preface

[ 17 ]

magnetometers, pressure and proximity sensors, etc. It will be explained in detail how to set up

IIO triggered buers and Industrial I/O events. Several IIO subsystem drivers are developed that

manage I2C DACs and SPI ADCs with hardware triggering interrupts. This chapter also explains

how to interact from user space with the SPI bus using the "spidev " driver.

Chapter 12, Using the Regmap API in Linux Device Drivers, provides an overview of the

regmap API, and explains how it will take care of calling the relevant calls of the SPI or I2C

subsystem replacing these buses specic core APIs. You will transform the SPI Input subsystem

driver of the Chapter 10, which uses specic SPI core APIs, into an IIO SPI subsystem driver,

which uses the Regmap API, keeping the same functionality between both drivers. Finally, you

will dive into the "IIO tools" applications to test the SPI IIO driver.

Terminology

New terms, important words and input terminal commands are set in bold.

When we wish to draw your aention to a particular part of a code block, the relevant lines or

items are set in bold.

Downloading the Kernel Modules Labs

The kernel modules developed in this book can be accessed through the GitHub repository at

hps://github.com/ALIBERA/linux_book_2nd_edion.

What You Need to Develop the Drivers

The drivers have been tested with an Ubuntu Desktop 14.04 LTS 64-bit system. You can download

Ubuntu Desktop at hps://www.ubuntu.com/download.

Eclipse Neon IDE for C/C++ developers has been used to write, compile and deploy the drivers.

You can download the Eclipse environment at hps://www.eclipse.org/downloads/packages/eclipse-

ide-cc-developers/neonr.

Go to the Neon Packages Release and download the Eclipse IDE for C/C++ developers (Linux 32-bit or

64-bit depending on your Linux host system).

The drivers and the applications have been ported to three dierent processors: NXP i.MX7D,

Microchip SAMA5D2 and Broadcom BCM2837, and these are the hardware platforms that were

used to develop them:

ATSAMA5D2B-XULT: The SAMA5D2 Xplained Ultra is a fast prototyping and evaluation

platform for the SAMA5D2 series of microprocessors (MPUs):

剩余587页未读，继续阅读

TerryLou

粉丝: 0
资源: 3

Linux嵌入式处理器驱动开发指南：实战教程

imx6ull嵌入式linux驱动开发指南pdf（正点原子）

嵌入式linux设备驱动开发详解

BF518嵌入式处理器的串口扩展及驱动程序设计.pdf

Linux嵌入式开发教程 ARM教程.zip_嵌入式linux驱动开发教程

LINUX嵌入式驱动开发

IDE_LINUX.rar_Linux驱动_linux ide_linux 硬盘_linux 驱动_嵌入式linux 驱动

嵌入式Linux驱动程序设计探究.pdf

嵌入式系统/ARM技术中的Cirrus Logic 嵌入式处理器

《嵌入式Linux驱动程序设计》.rar

"Linux设备驱动设计中的嵌入式处理器硬件基础详解

最新资源