Linux设备驱动开发详解

linux

device

需积分: 10 31 浏览量更新于2024-07-20 收藏 11.9MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

"Linux 设备驱动程序开发指南第三版" 本书是关于Linux设备驱动程序开发的权威指南，由Jonathan Corbet、Alessandro Rubini和Greg Kroah-Hartman三位专家共同撰写。书中深入浅出地介绍了如何构建和运行模块，以及如何设计和实现字符驱动。 1. 设备驱动的角色设备驱动是操作系统与硬件设备之间的桥梁，它负责管理和控制硬件设备，使其能够按照操作系统的指令工作。驱动程序处理设备输入输出、中断处理、数据转换等工作，确保软件层与物理硬件之间的高效通信。 2. 内核的分割在Linux系统中，内核被划分为核心部分和可加载模块。这样设计可以使得内核保持精简，同时允许添加或移除特定功能的驱动模块，以适应不同硬件配置和需求。 3. 设备类别和模块设备驱动通常分为字符设备、块设备、网络设备等类别。模块化设计使得驱动可以独立于内核主体，便于更新和维护。当需要支持新设备时，可以单独编译和加载对应的驱动模块。 4. 安全性考虑驱动程序设计需要考虑安全问题，防止恶意攻击。这包括权限管理、内存保护、错误处理等，以确保驱动程序在执行过程中不会对系统造成破坏。 5. 版本编号每个驱动程序都有版本号，用于追踪其开发历史和兼容性。内核和驱动版本之间需要协调以确保稳定运行。 6. 许可条款 Linux驱动程序通常遵循开源许可，如GPL（GNU General Public License），鼓励共享和改进代码。 7. 参与内核开发社区加入Linux内核开发社区意味着有机会与全球开发者合作，共同推动Linux技术的发展。 8. 构建和运行模块介绍如何设置测试环境，编写简单的“Hello World”模块，以及编译和加载模块到内核中的过程。同时，讨论了内核符号表、初始化和关闭机制、模块参数等概念。 9. 字符驱动程序字符驱动主要处理非缓冲I/O，例如串口和键盘。书中以scull设备为例，讲解了主要数据结构、设备注册、打开和释放、读写操作等内容，以及如何在用户空间中与这些新设备交互。 10. 主要和次要号码在Linux中，设备由一对主要和次要号码标识，用于区分同一类别的不同设备。通过本书，读者将掌握Linux设备驱动的基本原理和实践技巧，能够开发和调试自己的驱动程序，以支持各种硬件设备在Linux系统上的正常运行。

资源详情

资源推荐

This is the Title of the Book, eMatter Edition

Chapter 1

CHAPTER 1

An Introduction to

Device Drivers

One of the many advantages of free operating systems, as typified by Linux, is that

their internals are open for all to view. The operating system, once a dark and myste-

rious area whose code was restricted to a small number of programmers, can now be

readily examined, understood, and modified by anybody with the requisite skills.

Linux has helped to democratize operating systems. The Linux kernel remains a

large and complex body of code, however, and would-be kernel hackers need an

entry point where they can approach the code without being overwhelmed by com-

plexity. Often, device drivers provide that gateway.

Device drivers take on a special role in the Linux kernel. They are distinct “black

boxes” that make a particular piece of hardware respond to a well-defined internal

programming interface; they hide completely the details of how the device works.

User activities are performed by means of a set of standardized calls that are indepen-

dent of the specific driver; mapping those calls to device-specific operations that act

on real hardware is then the role of the device driver. This programming interface is

such that drivers can be built separately from the rest of the kernel and “plugged in”

at runtime when needed. This modularity makes Linux drivers easy to write, to the

point that there are now hundreds of them available.

There are a number of reasons to be interested in the writing of Linux device drivers.

The rate at which new hardware becomes available (and obsolete!) alone guarantees

that driver writers will be busy for the foreseeable future. Individuals may need to

know about drivers in order to gain access to a particular device that is of interest to

them. Hardware vendors, by making a Linux driver available for their products, can

add the large and growing Linux user base to their potential markets. And the open

source nature of the Linux system means that if the driver writer wishes, the source

to a driver can be quickly disseminated to millions of users.

This book teaches you how to write your own drivers and how to hack around in

related parts of the kernel. We have taken a device-independent approach; the pro-

gramming techniques and interfaces are presented, whenever possible, without being

tied to any specific device. Each driver is different; as a driver writer, you need to

,ch01.2168 Page 1 Thursday, January 20, 2005 9:21 AM

This is the Title of the Book, eMatter Edition

Chapter 1: An Introduction to Device Drivers

understand your specific device well. But most of the principles and basic tech-

niques are the same for all drivers. This book cannot teach you about your device,

but it gives you a handle on the background you need to make your device work.

As you learn to write drivers, you find out a lot about the Linux kernel in general;

this may help you understand how your machine works and why things aren’t

always as fast as you expect or don’t do quite what you want. We introduce new

ideas gradually, starting off with very simple drivers and building on them; every new

concept is accompanied by sample code that doesn’t need special hardware to be

tested.

This chapter doesn’t actually get into writing code. However, we introduce some

background concepts about the Linux kernel that you’ll be glad you know later,

when we do launch into programming.

The Role of the Device Driver

As a programmer, you are able to make your own choices about your driver, and

choose an acceptable trade-off between the programming time required and the flexi-

bility of the result. Though it may appear strange to say that a driver is “flexible,” we

like this word because it emphasizes that the role of a device driver is providing

mechanism, not policy.

The distinction between mechanism and policy is one of the best ideas behind the

Unix design. Most programming problems can indeed be split into two parts: “what

capabilities are to be provided” (the mechanism) and “how those capabilities can be

used” (the policy). If the two issues are addressed by different parts of the program,

or even by different programs altogether, the software package is much easier to

develop and to adapt to particular needs.

For example, Unix management of the graphic display is split between the X server,

which knows the hardware and offers a unified interface to user programs, and the

window and session managers, which implement a particular policy without know-

ing anything about the hardware. People can use the same window manager on dif-

ferent hardware, and different users can run different configurations on the same

workstation. Even completely different desktop environments, such as KDE and

GNOME, can coexist on the same system. Another example is the layered structure

of TCP/IP networking: the operating system offers the socket abstraction, which

implements no policy regarding the data to be transferred, while different servers are

in charge of the services (and their associated policies). Moreover, a server like ftpd

provides the file transfer mechanism, while users can use whatever client they prefer;

both command-line and graphic clients exist, and anyone can write a new user inter-

face to transfer files.

Where drivers are concerned, the same separation of mechanism and policy applies.

The floppy driver is policy free—its role is only to show the diskette as a continuous

,ch01.2168 Page 2 Thursday, January 20, 2005 9:21 AM

This is the Title of the Book, eMatter Edition

The Role of the Device Driver

array of data blocks. Higher levels of the system provide policies, such as who may

access the floppy drive, whether the drive is accessed directly or via a filesystem, and

whether users may mount filesystems on the drive. Since different environments usu-

ally need to use hardware in different ways, it’s important to be as policy free as

possible.

When writing drivers, a programmer should pay particular attention to this funda-

mental concept: write kernel code to access the hardware, but don’t force particular

policies on the user, since different users have different needs. The driver should deal

with making the hardware available, leaving all the issues about how to use the hard-

ware to the applications. A driver, then, is flexible if it offers access to the hardware

capabilities without adding constraints. Sometimes, however, some policy decisions

must be made. For example, a digital I/O driver may only offer byte-wide access to

the hardware in order to avoid the extra code needed to handle individual bits.

You can also look at your driver from a different perspective: it is a software layer

that lies between the applications and the actual device. This privileged role of the

driver allows the driver programmer to choose exactly how the device should appear:

different drivers can offer different capabilities, even for the same device. The actual

driver design should be a balance between many different considerations. For

instance, a single device may be used concurrently by different programs, and the

driver programmer has complete freedom to determine how to handle concurrency.

You could implement memory mapping on the device independently of its hardware

capabilities, or you could provide a user library to help application programmers

implement new policies on top of the available primitives, and so forth. One major

consideration is the trade-off between the desire to present the user with as many

options as possible and the time you have to write the driver, as well as the need to

keep things simple so that errors don’t creep in.

Policy-free drivers have a number of typical characteristics. These include support for

both synchronous and asynchronous operation, the ability to be opened multiple

times, the ability to exploit the full capabilities of the hardware, and the lack of soft-

ware layers to “simplify things” or provide policy-related operations. Drivers of this

sort not only work better for their end users, but also turn out to be easier to write

and maintain as well. Being policy-free is actually a common target for software

designers.

Many device drivers, indeed, are released together with user programs to help with

configuration and access to the target device. Those programs can range from simple

utilities to complete graphical applications. Examples include the tunelp program,

which adjusts how the parallel port printer driver operates, and the graphical cardctl

utility that is part of the PCMCIA driver package. Often a client library is provided as

well, which provides capabilities that do not need to be implemented as part of the

driver itself.

,ch01.2168 Page 3 Thursday, January 20, 2005 9:21 AM

This is the Title of the Book, eMatter Edition

Chapter 1: An Introduction to Device Drivers

The scope of this book is the kernel, so we try not to deal with policy issues or with

application programs or support libraries. Sometimes we talk about different poli-

cies and how to support them, but we won’t go into much detail about programs

using the device or the policies they enforce. You should understand, however, that

user programs are an integral part of a software package and that even policy-free

packages are distributed with configuration files that apply a default behavior to the

underlying mechanisms.

Splitting the Kernel

In a Unix system, several concurrent processes attend to different tasks. Each process

asks for system resources, be it computing power, memory, network connectivity, or

some other resource. The kernel is the big chunk of executable code in charge of han-

dling all such requests. Although the distinction between the different kernel tasks

isn’t always clearly marked, the kernel’s role can be split (as shown in Figure 1-1)

into the following parts:

Process management

The kernel is in charge of creating and destroying processes and handling their

connection to the outside world (input and output). Communication among dif-

ferent processes (through signals, pipes, or interprocess communication primi-

tives) is basic to the overall system functionality and is also handled by the

kernel. In addition, the scheduler, which controls how processes share the CPU,

is part of process management. More generally, the kernel’s process manage-

ment activity implements the abstraction of several processes on top of a single

CPU or a few of them.

Memory management

The computer’s memory is a major resource, and the policy used to deal with it

is a critical one for system performance. The kernel builds up a virtual address-

ing space for any and all processes on top of the limited available resources. The

different parts of the kernel interact with the memory-management subsystem

through a set of function calls, ranging from the simple malloc/free pair to much

more complex functionalities.

Filesystems

Unix is heavily based on the filesystem concept; almost everything in Unix can

be treated as a file. The kernel builds a structured filesystem on top of unstruc-

tured hardware, and the resulting file abstraction is heavily used throughout the

whole system. In addition, Linux supports multiple filesystem types, that is, dif-

ferent ways of organizing data on the physical medium. For example, disks may

be formatted with the Linux-standard ext3 filesystem, the commonly used FAT

filesystem or several others.

,ch01.2168 Page 4 Thursday, January 20, 2005 9:21 AM

This is the Title of the Book, eMatter Edition

Classes of Devices and Modules

Device control

Almost every system operation eventually maps to a physical device. With the

exception of the processor, memory, and a very few other entities, any and all

device control operations are performed by code that is specific to the device

being addressed. That code is called a device driver. The kernel must have

embedded in it a device driver for every peripheral present on a system, from the

hard drive to the keyboard and the tape drive. This aspect of the kernel’s func-

tions is our primary interest in this book.

Networking

Networking must be managed by the operating system, because most network

operations are not specific to a process: incoming packets are asynchronous

events. The packets must be collected, identified, and dispatched before a pro-

cess takes care of them. The system is in charge of delivering data packets across

program and network interfaces, and it must control the execution of programs

according to their network activity. Additionally, all the routing and address res-

olution issues are implemented within the kernel.

Loadable Modules

One of the good features of Linux is the ability to extend at runtime the set of fea-

tures offered by the kernel. This means that you can add functionality to the kernel

(and remove functionality as well) while the system is up and running.

Each piece of code that can be added to the kernel at runtime is called a module. The

Linux kernel offers support for quite a few different types (or classes) of modules,

including, but not limited to, device drivers. Each module is made up of object code

(not linked into a complete executable) that can be dynamically linked to the run-

ning kernel by the insmod program and can be unlinked by the rmmod program.

Figure 1-1 identifies different classes of modules in charge of specific tasks—a mod-

ule is said to belong to a specific class according to the functionality it offers. The

placement of modules in Figure 1-1 covers the most important classes, but is far from

complete because more and more functionality in Linux is being modularized.

Classes of Devices and Modules

The Linux way of looking at devices distinguishes between three fundamental device

types. Each module usually implements one of these types, and thus is classifiable as a

char module,ablock module,oranetwork module. This division of modules into dif-

ferent types, or classes, is not a rigid one; the programmer can choose to build huge

modules implementing different drivers in a single chunk of code. Good program-

mers, nonetheless, usually create a different module for each new functionality they

implement, because decomposition is a key element of scalability and extendability.

,ch01.2168 Page 5 Thursday, January 20, 2005 9:21 AM

剩余626页未读，继续阅读

帝霸阁

粉丝: 0
资源: 11

Linux设备驱动开发详解

Linux Device Driver / Essential Linux Device Drivers 中文版

Linux Device Driver 3：专家访谈与合并进展

linux device driver development pdf

linux device driver

Linux设备驱动代码？

make menuconifg中的<*> MMC block device driver 介 绍

写一个Linux驱动代码

adv7511 library

linux内核struct device_driver定义

linux内核struct device_driver结构体定义

usb摄像头 linux

Linux系统的GPIO驱动代码如何写

aurix qspi linux driver

struct device_driver结构体定义

写一个linux uart driver驱动框架

linux UDD driver

device_driver使用设备树注册流程，给出具体代码

SONY IMX516 Linux driver

module_i2c_driver of_match_table

怎么向linux内核注册deivce_driver设备

最新资源

make menuconifg中的<*> MMC block device driver 介绍