Linux设备驱动模型详解_linux设备驱动模型资源-CSDN文库

5星 · 超过95%的资源需积分: 50 187 浏览量 2017-08-25 08:35:12 上传评论 1 收藏 799KB PDF 举报

### Linux设备驱动模型详解 #### 一、引言 Linux操作系统因其开源性和强大的社区支持而成为服务器、嵌入式系统和个人计算机领域的首选操作系统之一。在Linux内核中，设备驱动模型是一个极其重要的组成部分，它负责管理和控制硬件资源，并提供统一的编程接口给上层应用程序。本文将深入探讨Linux设备模型的核心概念、关键数据结构以及相关的API，帮助读者更好地理解和掌握Linux设备驱动开发。 #### 二、Linux设备模型概述 Linux设备模型主要由以下几部分组成： 1. **设备注册与注销**：通过内核提供的API，可以注册和注销设备。 2. **类（Class）**：用于组织和管理具有相同特性的设备，例如USB设备或PCI设备。 3. **设备文件**：每个设备在文件系统中都有一个对应的设备文件，应用程序可以通过这些文件访问设备。 4. **设备节点**：每个设备都有一个唯一标识符，称为设备节点，它包括主设备号和次设备号。 5. **子系统（Subsystem）**：用于管理和监控特定类型的设备，如热插拔子系统或电源管理子系统。 #### 三、Linux设备模型中的核心数据结构 1. **`struct device`**：表示一个设备，包含设备的基本信息及其与系统的交互逻辑。 - `struct device *parent;`：指向父设备。 - `struct device *children;`：指向第一个子设备。 - `struct kobject kobj;`：用于与文件系统交互。 - `const struct device_ops *ops;`：设备的操作集合。 - `struct device_private *p;`：私有数据指针。 2. **`struct class`**：表示设备类别，用于组织和管理同一类型的设备。 - `struct module *owner;`：拥有这个类别的模块。 - `struct list_head devices;`：所有属于该类别的设备列表。 - `struct attribute_group **dev_groups;`：设备属性组。 - `const struct class_ops *class_ops;`：类别操作集合。 3. **`struct device_driver`**：表示一个驱动程序。 - `const char *name;`：驱动名称。 - `struct bus_type *bus;`：所支持的总线类型。 - `const struct of_device_id *of_match_table;`：设备匹配表。 - `int (*probe)(struct device *, const struct of_device_id *);`：探测函数。 - `int (*remove)(struct device *);`：移除函数。 #### 四、Linux设备模型的关键API 1. **设备注册与注销** - `int device_register(struct device *device);`：注册一个设备。 - `void device_unregister(struct device *device);`：注销一个设备。 2. **设备操作** - `int device_set_wakeup_enable(struct device *dev, bool enabled);`：设置设备唤醒能力。 - `void device_lock_sleep(struct device *dev);`：锁定设备睡眠状态。 - `void device_unlock_sleep(struct device *dev);`：解锁设备睡眠状态。 3. **类操作** - `int class_register(struct class *class);`：注册一个设备类别。 - `void class_unregister(struct class *class);`：注销一个设备类别。 4. **驱动程序操作** - `int driver_register(struct device_driver *driver);`：注册一个驱动程序。 - `void driver_unregister(struct device_driver *driver);`：注销一个驱动程序。 #### 五、Linux设备模型中的双向循环链表在Linux内核中，双向循环链表是一种非常常见的数据结构，它被广泛应用于各种队列的基础构建。例如，在设备模型中，`struct list_head` 结构体被用于构建设备链表，以高效地管理设备。 1. **链表结构定义** - `struct list_head { struct list_head *next, *prev; };` 2. **链表初始化** - `#define LIST_HEAD_INIT(name) { &(name), &(name) }` - `#define LIST_HEAD(name) struct list_head name = LIST_HEAD_INIT(name);` - `static inline void INIT_LIST_HEAD(struct list_head *list) { list->next = list; list->prev = list; }` 3. **链表节点添加** - `static inline void __list_add(struct list_head *new, struct list_head *prev, struct list_head *next)` - `static inline void list_add(struct list_head *new, struct list_head *head)` - `static inline void list_add_tail(struct list_head *new, struct list_head *head)` 4. **链表节点删除** - `static inline void __list_del(struct list_head *prev, struct list_head *next)` - `static inline void list_del(struct list_head *entry)` - `static inline void list_del_init(struct list_head *entry)` 5. **链表节点替换** - `static inline void list_replace(struct list_head *old, struct list_head *new)` - `static inline void list_replace_init(struct list_head *old, struct list_head *new)` 6. **链表节点移动** - `static inline void list_move(struct list_head *list, struct list_head *head)` 通过这些API，我们可以高效地管理设备模型中的设备，实现对硬件资源的有效控制和利用。 #### 六、总结本文详细介绍了Linux设备模型的关键概念、数据结构和API，旨在帮助读者理解Linux设备驱动模型的工作原理和实现细节。掌握这些基础知识对于进行Linux设备驱动开发非常重要。希望本文能够为您的学习和研究提供一定的参考价值。

资源推荐

资源详情

资源评论

linux 内核部件分析（一）——连通世界的 list

在 linux 内核中，有一种通用的双向循环链表，构成了各种队列的基础。链表的结构定义和

相关函数均在 include/linux/list.h 中，下面就来全面的介绍这一链表的各种 API。

struct list_head {

struct list_head *next, *prev;

};

这是链表的元素结构。因为是循环链表，表头和表中节点都是这一结构。有 prev 和 next 两

个指针，分别指向链表中前一节点和后一节点。

#define LIST_HEAD_INIT(name) { &(name), &(name) }

#define LIST_HEAD(name) \

struct list_head name = LIST_HEAD_INIT(name)

static inline void INIT_LIST_HEAD(struct list_head *list)

{

list->next = list;

list->prev = list;

}

在初始化的时候，链表头的 prev 和 next 都是指向自身的。

static inline void __list_add(struct list_head *new,

struct list_head *prev,

struct list_head *next)

{

next->prev = new;

new->next = next;

new->prev = prev;

prev->next = new;

}

static inline void list_add(struct list_head *new, struct list_head *head)

{

__list_add(new, head, head->next);

}

static inline void list_add_tail(struct list_head *new, struct list_head *head)

{

__list_add(new, head->prev, head);

}

双向循环链表的实现，很少有例外情况，基本都可以用公共的方式来处理。这里无论是加第

一个节点，还是其它的节点，使用的方法都一样。

另外，链表 API 实现时大致都是分为两层：一层外部的，如 list_add、list_add_tail，用来消

除一些例外情况，调用内部实现；一层是内部的，函数名前会加双下划线，如__list_add，

往往是几个操作公共的部分，或者排除例外后的实现。

static inline void __list_del(struct list_head * prev, struct list_head * next)

{

next->prev = prev;

prev->next = next;

}

static inline void list_del(struct list_head *entry)

{

__list_del(entry->prev, entry->next);

entry->next = LIST_POISON1;

entry->prev = LIST_POISON2;

}

static inline void list_del_init(struct list_head *entry)

{

__list_del(entry->prev, entry->next);

INIT_LIST_HEAD(entry);

}

list_del 是链表中节点的删除。之所以在调用__list_del 后又把被删除元素的 next、prev 指向

特殊的 LIST_POSITION1 和 LIST_POSITION2，是为了调试未定义的指针。

list_del_init 则是删除节点后，随即把节点中指针再次初始化，这种删除方式更为实用。

static inline void list_replace(struct list_head *old,

struct list_head *new)

{

new->next = old->next;

new->next->prev = new;

new->prev = old->prev;

new->prev->next = new;

}

static inline void list_replace_init(struct list_head *old,

struct list_head *new)

{

list_replace(old, new);

INIT_LIST_HEAD(old);

}

list_replace 是将链表中一个节点 old，替换为另一个节点 new。从实现来看，即使 old 所在

地链表只有 old 一个节点，new 也可以成功替换，这就是双向循环链表可怕的通用之处。

list_replace_init 将被替换的 old 随即又初始化。

static inline void list_move(struct list_head *list, struct list_head *head)

{

__list_del(list->prev, list->next);

list_add(list, head);

}

static inline void list_move_tail(struct list_head *list,

struct list_head *head)

{

__list_del(list->prev, list->next);

list_add_tail(list, head);

}

list_move 的作用是把 list 节点从原链表中去除，并加入新的链表 head 中。

list_move_tail 只在加入新链表时与 list_move 有所不同，list_move 是加到 head 之后的链表头

部，而 list_move_tail 是加到 head 之前的链表尾部。

static inline int list_is_last(const struct list_head *list,

const struct list_head *head)

{

return list->next == head;

}

list_is_last 判断 list 是否处于 head 链表的尾部。

static inline int list_empty(const struct list_head *head)

{

return head->next == head;

}

static inline int list_empty_careful(const struct list_head *head)

{

struct list_head *next = head->next;

return (next == head) && (next == head->prev);

}

list_empty 判断 head 链表是否为空，为空的意思就是只有一个链表头 head。

list_empty_careful 同样是判断 head 链表是否为空，只是检查更为严格。

static inline int list_is_singular(const struct list_head *head)

{

return !list_empty(head) && (head->next == head->prev);

}

list_is_singular 判断 head 中是否只有一个节点，即除链表头 head 外只有一个节点。

static inline void __list_cut_position(struct list_head *list,

struct list_head *head, struct list_head *entry)

{

struct list_head *new_first = entry->next;

list->next = head->next;

list->next->prev = list;

list->prev = entry;

entry->next = list;

head->next = new_first;

new_first->prev = head;

}

static inline void list_cut_position(struct list_head *list,

struct list_head *head, struct list_head *entry)

{

if (list_empty(head))

return;

if (list_is_singular(head) &&

(head->next != entry && head != entry))

return;

if (entry == head)

INIT_LIST_HEAD(list);

else

__list_cut_position(list, head, entry);

}

list_cut_position 用于把 head 链表分为两个部分。从 head->next 一直到 entry 被从 head 链表

中删除，加入新的链表 list。新链表 list 应该是空的，或者原来的节点都可以被忽略掉。可

以看到，list_cut_position 中排除了一些意外情况，保证调用__list_cut_position 时至少有一个

元素会被加入新链表。

static inline void __list_splice(const struct list_head *list,

struct list_head *prev,

struct list_head *next)

{

struct list_head *first = list->next;

struct list_head *last = list->prev;

first->prev = prev;

prev->next = first;

last->next = next;

next->prev = last;

}

static inline void list_splice(const struct list_head *list,

struct list_head *head)

{

if (!list_empty(list))

__list_splice(list, head, head->next);

}

static inline void list_splice_tail(struct list_head *list,

struct list_head *head)

{

if (!list_empty(list))

__list_splice(list, head->prev, head);

}

list_splice 的功能和 list_cut_position 正相反，它合并两个链表。list_splice 把 list 链表中的节

点加入 head 链表中。在实际操作之前，要先判断 list 链表是否为空。它保证调用__list_splice

时 list 链表中至少有一个节点可以被合并到 head 链表中。

list_splice_tail 只是在合并链表时插入的位置不同。list_splice 是把原来 list 链表中的节点全

加到 head 链表的头部，而 list_splice_tail 则是把原来 list 链表中的节点全加到 head 链表的尾

部。

static inline void list_splice_init(struct list_head *list,

struct list_head *head)

{

if (!list_empty(list)) {

__list_splice(list, head, head->next);

INIT_LIST_HEAD(list);

}

static inline void list_splice_tail_init(struct list_head *list,

struct list_head *head)

{

if (!list_empty(list)) {

__list_splice(list, head->prev, head);

INIT_LIST_HEAD(list);

}

list_splice_init 除了完成 list_splice 的功能，还把变空了的 list 链表头重新初始化。

list_splice_tail_init 除了完成 list_splice_tail 的功能，还吧变空了得 list 链表头重新初始化。

list 操作的 API 大致如以上所列，包括链表节点添加与删除、节点从一个链表转移到另一个

链表、链表中一个节点被替换为另一个节点、链表的合并与拆分、查看链表当前是否为空或

者只有一个节点。接下来，是操作链表遍历时的一些宏，我们也简单介绍一下。

#define list_entry(ptr, type, member) \

container_of(ptr, type, member)

list_entry 主要用于从 list 节点查找其内嵌在的结构。比如定义一个结构 struct A{ struct

list_head list; }; 如果知道结构中链表的地址 ptrList，就可以从 ptrList 进而获取整个结构的地

址(即整个结构的指针) struct A *ptrA = list_entry(ptrList, struct A, list);

这种地址翻译的技巧是 linux 的拿手好戏，container_of 随处可见，只是链表节点多被封装在

更复杂的结构中，使用专门的 list_entry 定义也是为了使用方便。

#define list_first_entry(ptr, type, member) \

list_entry((ptr)->next, type, member)

list_first_entry 是将 ptr 看完一个链表的链表头，取出其中第一个节点对应的结构地址。使用

list_first_entry 是应保证链表中至少有一个节点。

#define list_for_each(pos, head) \

for (pos = (head)->next; prefetch(pos->next), pos != (head); \

pos = pos->next)

list_for_each 循环遍历链表中的每个节点，从链表头部的第一个节点，一直到链表尾部。中

间的 prefetch 是为了利用平台特性加速链表遍历，在某些平台下定义为空，可以忽略。

#define __list_for_each(pos, head) \

for (pos = (head)->next; pos != (head); pos = pos->next)

__list_for_each 与 list_for_each 没什么不同，只是少了 prefetch 的内容，实现上更为简单易懂。

#define list_for_each_prev(pos, head) \

for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \

pos = pos->prev)

list_for_each_prev 与 list_for_each 的遍历顺序相反，从链表尾逆向遍历到链表头。

#define list_for_each_safe(pos, n, head) \

for (pos = (head)->next, n = pos->next; pos != (head); \

pos = n, n = pos->next)

list_for_each_safe 也是链表顺序遍历，只是更加安全。即使在遍历过程中，当前节点从链表

中删除，也不会影响链表的遍历。参数上需要加一个暂存的链表节点指针 n。

#define list_for_each_prev_safe(pos, n, head) \

for (pos = (head)->prev, n = pos->prev; \

剩余135页未读，继续阅读

评论收藏

内容反馈

忧伤的石一

2023-07-28

作者在文中给出了一些实际应用场景，帮助读者将理论知识与实践结合起来，使得这篇文件更有参考价值。
呆呆美要暴富

2023-07-28

这篇文件通俗易懂，并没有使用过多的专业术语，适合初学者阅读和理解。
柔粟

2023-07-28

这篇文件详细解释了Linux设备驱动模型，让我对其有了更深刻的理解。
玛卡库克

2023-07-28

文档结构清晰，每个模块都有独立的介绍，循序渐进地阐述了Linux设备驱动的核心概念。
焦虑肇事者

2023-07-28

文章中的实例很丰富，让我能够更好地理解Linux设备驱动的工作原理。

匿名打工仔

粉丝: 24
资源: 16

Linux设备驱动模型详解

Linux设备驱动模型框架的分类研究.pdf

linux设备驱动模型

Linux 设备模型详细分析

linux下驱动模型介绍

Linux设备模型

浅析linux设备模型—（详解设备与驱动）

Linux设备模型（总线、设备、驱动程序和类）

linux内核驱动模型

Linux总线、设备和驱动模型

Linux设备驱动开发详解：基于最新的Linux4.0内核,linux设备驱动开发详解pdf,LINUX

《Linux设备驱动开发详解-基于最新的Linux4.0内核》源码

Linux设备驱动开发详解-基于最新的Linux4.0内核》配套代码.zip

《Linux设备驱动开发详解-基于最新的Linux4.0内核》源码.zip

《Linux 设备驱动开发详解》（宋宝华） 学习笔记.zip

linux 设备模型浅析 设备篇

Linux总线、设备、驱动模型

对_Linux_设备驱动模型的一些理解.pdf

内核设备驱动模型精华

总线设备驱动模型总结

linux设备模型.pdf

Linux 设备模型之终端设备（tty）驱动架构分析

linux PCIE架构详解

Linux设备驱动程序原理及框架

Linux设备驱动开发详解-基于最新的Linux4.0内核

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

inux设备驱动开发详解：基于最新的Linux4.0内核配套光盘

LINUX 设备驱动开发详解 源码

Linux设备驱动开发详解：基于最新的Linux4.0内核,linux设备驱动开发详解pdf,LINUX源码.zip

最新资源

《Linux 设备驱动开发详解》（宋宝华）学习笔记.zip

linux 设备模型浅析设备篇

LINUX 设备驱动开发详解源码