概念

kobject和kset是Linux内核中用于管理内核对象的基本概念。都是一个结构体

struct kobject{ const char *name; struct list_headentry; struct kobject *parent; ... }

kobject全称是kernel object，即内核对象。

• 它是 Linux 内核设备模型的基础基石，用于统一管理内核中的各种对象（设备、驱动、总线等）。
• 每一个 kobject 实例，都会在/sys/目录下对应生成一个目录，通过 sysfs 文件系统向用户态暴露内核信息。

kset(内核对象集合)是一种用于组织和管理一组相关kobject的容器，结构体如下：

struct kset { struct list_head list; // 链接该集合下所有的 kobject spinlock_t list_lock; struct kobject kobj; // 自身作为一个内核对象 const struct kset_uevent_ops *uevent_ops; ... };

kset 和kobject 的关系

kobject创建

struct kobject *kobject_create_and_add(const char *name, struct kobject *parent);

#include<linux/kobject.h> #include <linux/module.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/configfs.h> #include <linux/kernel.h> #include <linux/kobject.h> /* 定义 3 个 kobject 指针，用来保存创建出来的内核对象 */ struct kobject *mykobject01; struct kobject *mykobject02; struct kobject *mykobject03; /* 定义 kobject 类型（必须要有，第二种创建方法需要） */ struct kobj_type mytype; /* 模块初始化函数（加载模块时执行） */ static int mykobj_init(void) { int ret; mykobject01 = kobject_create_and_add("mykobject01", NULL); mykobject02 = kobject_create_and_add("mykobject02", mykobject01); /* ====================== 第二种创建 kobject 的方法 ====================== * 分两步： * 1. 分配 kobject 内存 * 2. 初始化并添加到内核 */ // 分配内存 mykobject03 = kzalloc(sizeof(struct kobject), GFP_KERNEL); // 初始化并添加到 /sys/ 根目录，名字 mykobject03 ret = kobject_init_and_add(mykobject03, &mytype, NULL, "%s", "mykobject03"); return 0; } /* 模块退出函数（卸载模块时执行） */ static void mykobj_exit(void) { /* 释放所有 kobject（必须做，否则内存泄漏） */ kobject_put(mykobject01); kobject_put(mykobject02); kobject_put(mykobject03); } /* 注册模块入口/出口 */ module_init(mykobj_init); module_exit(mykobj_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("topeet");

创建kset

/** * kset_create_and_add - 动态创建一个 struct kset 并将其添加到 sysfs 文件系统 * * @name: 该 kset 的名称（对应 /sys/ 下的目录名） * @uevent_ops: 该 kset 对应的 struct kset_uevent_ops 结构体指针 * （用于处理用户态事件通知，如热插拔等） * @parent_kobj: 该 kset 的父 kobject（即父目录），如果没有则传 NULL * * 该函数会动态创建一个 kset 结构体，并将其注册到 sysfs 中。 * 当你不再使用该结构体时，需要调用 kset_unregister()， * 该结构体会在不再被引用时被自动释放。 * * 如果 kset 创建失败，函数将返回 NULL。 */ struct kset *kset_create_and_add(const char *name, const struct kset_uevent_ops *uevent_ops, struct kobject *parent_kobj);

#include <linux/module.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/configfs.h> #include <linux/kernel.h> #include <linux/kobject.h> struct kobject *mykobject01; struct kobject *mykobject02; struct kset *mykset; struct kobj_type mytype; // 模块的初始化函数 static int mykobj_init(void) { int ret; // 创建并添加kset，名称为mykset，父kobject为NULL，事件操作集为NULL mykset = kset_create_and_add("mykset", NULL, NULL); mykobject01 = kzalloc(sizeof(struct kobject), GFP_KERNEL); mykobject01->kset = mykset; // 初始化并添加mykobject01到sysfs，名称为mykobject01 ret = kobject_init_and_add(mykobject01, &mytype, NULL, "%s", "mykobject01"); // 为mykobject02分配内核内存 mykobject02 = kzalloc(sizeof(struct kobject), GFP_KERNEL); // 将mykobject02归属到mykset集合中 mykobject02->kset = mykset; // 初始化并添加mykobject02到sysfs，名称为mykobject02 ret = kobject_init_and_add(mykobject02, &mytype, NULL, "%s", "mykobject02"); return 0; } // 模块退出函数 static void mykobj_exit(void) { // 释放mykobject01的引用计数 kobject_put(mykobject01); // 释放mykobject02的引用计数 kobject_put(mykobject02); kset_unregister(mykset); }

设备模型简介

设备模型通过提供统一的设备描述和管理机制，简化了 驱动的编写和维护过程，提高了代码的复用性和可维护性，设备模型包含以下四个概念：

1. 总线（Bus）

总线是CPU 与设备之间进行信息交互的通道，所有设备都需要连接到总线上。总线分为两类：

• 虚拟总线：如 platform 总线，用于管理无真实物理总线的设备。
• 外设总线：如 I2C、SPI、USB、PCI 等真实物理总线。

2. 设备（Device）

将系统中所有硬件设备的共同属性（如名字、属性、从属关系、所属类等）抽象出来，就形成了device结构体，代表一个具体的硬件设备实例。

3. 类（Class）

具有相似功能或属性的设备集合，用于对设备进行逻辑分类。

• 类比理解：早饭、午饭、晚饭都属于 “饭” 这一类；输入设备（键盘、鼠标）都属于input类。
• 在/sys/class/下可以看到各类设备的目录。

4. 驱动（Driver）

对应硬件设备的驱动程序，负责与硬件交互、实现设备功能，并与内核其他子系统协作。

• 驱动会向总线注册，当总线上有匹配的设备时，总线会自动将设备与驱动绑定。

什么是sysfs文件系统

它以一种层次结构的方式组织数据，并将这些数据表示为文 件和目录，使得用户空间可以通过文件系统接口访问和操作内核对象的属性

比如：当使用kobject 时，通常不会单独使用它，而是将其嵌入到一个数据结构中。这样做的目 的是将高级对象接入到设备模型中。比如cdev结构体和platform_device结构体，如下所示： cdev 结构体如下所示，其成员有kobject

所以我们也可以把总线，设备，驱动看作是kobject的派生类。因为他们都是设备模型中 的实体，通过继承或扩展kobject来实现与设备模型的集成

和设备模型有关的文件夹为bus，class，devices。完整路径为如下所示：

/sys/bus /sys/class /sys/devices

1：/sys/devices

/sys/devices：该目录主要展示设备的层次架构

2:/sys/bus

该目录包含了总线类型的子目录。每个子目录代表一个特定类型的总线，例如 PCI、USB 等。每个总线子目录中包含与该总线相关的设备和驱动程序的信息

3:/sys/class：

该目录包含了设备类别的子目录。每个子目录代表一个设备类别，例如磁盘、 网络接口等。每个设备类别子目录中包含了属于该类别的设备的信息。如下图所示：

4:sys 目录层次图解

引用计数器(open,close哪种差不多引用)

引用计数器（referencecounting）是一种内存管理技术，用于跟踪对象或资源的引用数量。 它通过在对象被引

引用计数器的基本原理如下：

1:对象或资源被创建时，引用计数器初始化为1。

2:当有新的引用指向对象或资源时，引用计数器增加。

3:当引用不再指向对象或资源时（引用被删除、超出作用域等），引用计数器减少。

4:当引用计数器的值为0时，表示没有任何引用指向对象或资源，可以安全地释放对象或资 源，并进行相关的清理操作。

structkref定义在include/linux/kref.h 头文件当中，本质是一个int型变量

struct kref { refcount_t refcount; }; typedef struct { atomic_t refs; } refcount_t; typedef struct { int counter; } atomic_t; 在 Linux 系统中，引用计数器用结构体 kref 来表示。 struct kref 定义在 include/linux/kref.h 头文件当中，本质是一个 int 型变量。

在使用引用计数器时，通常会将结构体kref嵌入到其他结构体中，例如struct kobject

struct kobject { const char *name; // 该 kobject 的名称（对应 sysfs 目录名） ... struct kref kref; // 引用计数器，用于管理对象生命周期 };

图解如下:

释放Kobject

一、两种创建方法对比 - kobject_create_and_add：

自动申请内存，自动使用内置 ktype - kobject_init_and_add：

手动申请内存，需自己实现 ktype -

本质：底层流程一致，最终都会在 sysfs 中创建目录

二、kobject_create_and_add 调用流程

kobject_create_and_add └── kobject_create ├── kzalloc (自动分配内存)

└── kobject_init (使用内置 dynamic_kobj_ktype) └── kobject_add └── kobject_add_varg └── kobject_add_internal └── create_dir └── sysfs_create_dir_ns (创建 sysfs 目录)

三、kobject_init_and_add 调用流程

kobject_init_and_add ├── kobject_init (需自己提供 ktype) └── kobject_add_varg └── kobject_add_internal └── create_dir └── sysfs_create_dir_ns (创建 sysfs 目录) 四、释放逻辑（两种方法一致） - 统一调用 kobject_put() - 引用计数归 0 时，自动执行 kobj_type->release() - 完成内存与资源的释放

当引用计数器变为0的时候，调用kobject_type里面的release函数释放内存

完善kobject_type结构体

#include<linux/kobject.h> struct kobject *mykobject03; /* * 动态创建的 kobject 释放函数 * 作用：当 kobject 引用计数为 0 时，内核自动调用此函数 */ static void dynamic_kobj_release(struct kobject *kobj) { /* 打印调试信息：__func__ 代表当前函数名 */ printk("kobject:(%p):%s\n", kobj, __func__); /* 释放 kobject 占用的内核内存 */ kfree(kobj); } //自定义Type struct kobj_type mytype{ .release=dynamic_kobj_release; } // 模块的初始化函数 static int mykobj_init(void) { int ret; // 创建 kobject 的第二种方法 // 1. 使用 kzalloc 函数分配了一个 kobject 对象的内存 mykobject03 = kzalloc(sizeof(struct kobject), GFP_KERNEL); // 2. 初始化并添加到内核中，名为 "mykobject03" ret = kobject_init_and_add(mykobject03, &mytype, NULL, "%s", "mykobject03"); return 0; }

在计数器为0的时候自动执行Mytype里面的release函数

第二种方法创建属性文件并实现读写

1:所有属性文件读写函数走一个代码

代码如下:

attribute是kobject下面的属性，然后sysfs对kobject和属性进行读写，所有的属性文件读写都会调用一个函数，所以要加if判断

#include <linux/module.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/configfs.h> #include <linux/kernel.h> #include <linux/kobject.h> #include <linux/sysfs.h> // 自定义的kobject结构体，包含一个kobject对象和两个整型值 struct mykobj { struct kobject kobj; int value1; int value2; }; // 定义mykobj结构体指针变量mykobject01 struct mykobj *mykobject01; // 自定义的kobject释放函数 static void dynamic_kobj_release(struct kobject *kobj) { struct mykobj *mykobject01 = container_of(kobj, struct mykobj, kobj); printk("kobject:(%p):%s\n", kobj, __func__); kfree(mykobject01); } // 自定义的attribute对象value1和value2 struct attribute value1 = { .name = "value1", .mode = 0666, }; struct attribute value2 = { .name = "value2", .mode = 0666, }; // 将attribute对象放入数组中 struct attribute *myattr[] = { &value1, &value2, NULL, }; // 自定义的show函数，用于读取属性值 ssize_t myshow(struct kobject *kobj, struct attribute *attr, char *buf) { ssize_t count; struct mykobj *mykobject01 = container_of(kobj, struct mykobj, kobj); if (strcmp(attr->name, "value1") == 0) { count = sprintf(buf, "%d\n", mykobject01->value1); } else if (strcmp(attr->name, "value2") == 0) { count = sprintf(buf, "%d\n", mykobject01->value2); } else { count = 0; } return count; } // 自定义的store函数，用于写入属性值 ssize_t mystore(struct kobject *kobj, struct attribute *attr, const char *buf, size_t size) { struct mykobj *mykobject01 = container_of(kobj, struct mykobj, kobj); if (strcmp(attr->name, "value1") == 0) { sscanf(buf, "%d\n", &mykobject01->value1); } else if (strcmp(attr->name, "value2") == 0) { sscanf(buf, "%d\n", &mykobject01->value2); } return size; } // 自定义的sysfs_ops结构体，包含show和store函数指针 struct sysfs_ops myops = { .show = myshow, .store = mystore, }; // 自定义的kobj_type结构体，包含释放函数、默认属性和sysfs_ops static struct kobj_type mytype = { .release = dynamic_kobj_release, .default_attrs = myattr, .sysfs_ops = &myops, }; // 模块的初始化函数 static int mykobj_init(void) { int ret; // 分配并初始化mykobject01 mykobject01 = kzalloc(sizeof(struct mykobj), GFP_KERNEL); mykobject01->value1 = 1; mykobject01->value2 = 1; // 初始化并添加mykobject01到内核中，名为"mykobject01" ret = kobject_init_and_add(&mykobject01->kobj, &mytype, NULL, "%s", "mykobject01"); return 0; }

这种方法太臃肿，多个属性文件对应一个读写函数

2:所有属性文件读写函数走自己的代码

#include <linux/module.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/configfs.h> #include <linux/kernel.h> #include <linux/kobject.h> #include <linux/sysfs.h> // 自定义的show函数，用于读取属性value1 ssize_t show_myvalue1(struct kobject *kobj, struct kobj_attribute *attr, char *buf) { ssize_t count; count = sprintf(buf, "show_myvalue1\n"); return count; } // 自定义的store函数，用于写入属性value1 ssize_t store_myvalue1(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count) { printk("buf is %s\n", buf); return count; } // 自定义的show函数，用于读取属性value2 ssize_t show_myvalue2(struct kobject *kobj, struct kobj_attribute *attr, char *buf) { ssize_t count; count = sprintf(buf, "show_myvalue2\n"); return count; } // 自定义的store函数，用于写入属性value2 ssize_t store_myvalue2(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count) { printk("buf is %s\n", buf); return count; } // 定义attribute对象 value1 和 value2，后面参数为读写函数 struct kobj_attribute value1 = __ATTR(value1, 0664, show_myvalue1, store_myvalue1); struct kobj_attribute value2 = __ATTR(value2, 0664, show_myvalue2, store_myvalue2); // 自定义的kobject释放函数 static void dynamic_kobj_release(struct kobject *kobj) { struct mykobj *mykobject01 = container_of(kobj, struct mykobj, kobj); printk("kobject: (%p): %s\n", kobj, __func__); kfree(mykobject01); } // 将attribute对象放入数组中 struct attribute *myattr[] = { &value1.attr, &value2.attr, NULL, }; // 统一的show分发函数 ssize_t myshow(struct kobject *kobj, struct attribute *attr, char *buf) { ssize_t count; struct kobj_attribute *kobj_attr = container_of(attr, struct kobj_attribute, attr); count = kobj_attr->show(kobj, kobj_attr, buf); return count; } // 统一的store分发函数 ssize_t mystore(struct kobject *kobj, struct attribute *attr, const char *buf, size_t size) { struct kobj_attribute *kobj_attr = container_of(attr, struct kobj_attribute, attr); return kobj_attr->store(kobj, kobj_attr, buf, size); } // 自定义的sysfs_ops结构体 struct sysfs_ops myops = { .show = myshow, .store = mystore, }; // 自定义的kobj_type结构体 static struct kobj_type mytype = { .release = dynamic_kobj_release, .default_attrs = myattr, .sysfs_ops = &myops, };

第一种方法创建Kobject下面创建属性文件

1：单个属性文件添加

在上一个代码上做实验,api，

/* *struct kobject kobj→ 你要给谁创建文件（目录） *const struct attribute attr→ 你要创建的属性文件（名字、权限、show/store） */ int sysfs_create_file(struct kobject *kobj, const struct attribute *attr);

// 定义attribute对象 value1 和 value2，后面参数为读写函数 struct kobj_attribute value1 = __ATTR(value1, 0664, show_myvalue1, store_myvalue1); struct kobj_attribute value2 = __ATTR(value2, 0664, show_myvalue2, store_myvalue2); static int mykobj_init(void) { int ret; mykobject01 = kobject_create_and_add("mykobject01", NULL); ret = sysfs_create_file(mykobject01, &value1.attr); ret = sysfs_create_file(mykobject01, &value2.attr); return ret; }

2：多个属性文件添加

api函数

int sysfs_create_group(struct kobject *kobj, const struct attribute_group *grp)

struct attribute_group { const char *name; const struct attribute **attrs; mode_t (*is_visible)(struct kobject *kobj, struct attribute *attr, int index); };

代码如下:

struct attribute *attrs[] = { &value1.attr, &value2.attr, NULL, }; const struct attribute_group attr_group={ .name="my_group", .attrs=attrs, }; sysfs_create_group(kobj,&attr_group);

总线

实现一个自己的总线

struct bus_type { const char *name; // 1. 总线名字（如 platform、i2c、spi // ========== 【三个最核心！你天天用的！】========== int (*match)(struct device *dev, struct device_driver *drv); // 3. 匹配函数：设备 <-> 驱动 配对 int (*probe)(struct device *dev); // 4. 总线兜底probe（几乎不用） int (*remove)(struct device *dev); };

代码如下:

int mybus_match(struct device *dev,struct device_driver *drv) { //检查设备名称和驱动程序名称是否匹配 return(strcmp(dev_name(dev),drv->name)==0); }; int mybus_probe(struct device*dev) { struct device_driver *drv=dev->driver; if(drv->probe) drv->probe(dev); return 0; } struct bus_type mybus={ .name="mybus", //总线的名称 .match=mybus_match, //设备和驱动程序匹配的回调函数 .probe=mybus_probe, //设备探测的回调函数 }; static intbus_init(void) { int ret; ret=bus_register(&mybus); //注册总线 }

这样就在/sys/bus/下面注册了一个你自己的总线，匹配规则就是match

字符串一样返回1代表匹配成功，就执行probe函数

总线下创建属性API函数

//bus_create_file() 函数用于在总线的 sysfs 目录下创建一个属性文件。 // 示例 // 正确的、驱动用的 bus_create_file —— 只有 2 个参数！ int bus_create_file(struct bus_type *bus, const struct bus_attribute *attr);

// 定义总线属性结构体 struct bus_attribute mybus_attr = { .attr = { .name = "value", .mode = 0664, }, .show = mybus_show, }; // 创建总线 sysfs 文件 ret = bus_create_file(&mybus, &mydevice.kobj, &mybus_attr.attr);

bus_register()函数理论分析:

bus_register()函数理论分析 一、函数基本概述 bus_register()是Linux内核设备模型中总线注册的核心入口函数，作用是将自定义struct bus_type总线结构体完整注册到Linux内核设备模型子系统中，完成总线初始化、内核对象注册、链表初始化、sysfs目录创建、设备驱动管理框架搭建等全部工作。 总线注册完成后，该总线才可以挂载设备、挂载驱动、执行设备驱动匹配逻辑。 二、总线对应核心结构体struct bus_type struct bus_type { const char *name; //总线名称，对应sysfs目录名 int (*match)(struct device *dev, struct device_driver *drv); //设备驱动匹配函数 int (*probe)(struct device *dev); //总线兜底probe初始化函数 void *p; //总线私有数据指针，内核自动分配 }; 总线私有数据struct subsys_private内部包含：总线kobject内核对象、设备链表klist_devices、驱动链表klist_drivers、总线互斥锁、sysfs属性相关数据。 三、bus_register()内部完整执行流程&函数调用顺序 1. 内核分配总线私有数据struct subsys_private内存空间 2. 初始化总线内部两个klist双向链表： klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put); 设备链表绑定get/put引用计数函数，支持节点增删改查遍历操作 klist_init(&priv->klist_drivers, NULL, NULL); 驱动链表不绑定get/put引用计数函数，无引用保护，内核禁止增删改查遍历，仅做占位记录 3. 初始化总线并发访问互斥锁，防止设备驱动注册并发竞态问题 4. 初始化总线对应的kobject内核对象，设置总线名称，绑定父节点到/sys/bus目录 5. 调用subsystem_register()函数注册总线子系统内核对象 6. 在sysfs文件系统/sys/bus/目录下创建对应总线名称的总线根目录 7. 在总线根目录下自动创建devices、drivers两个子目录 8. 调用bus_create_file()函数创建总线默认sysfs属性文件（uevent等） 9. 将总线私有数据priv赋值给bus->p，完成总线和私有数据、链表、kobject的绑定关联 10. 返回注册结果：成功返回0，失败返回负数错误码 四、内部关键子函数调用关系 bus_register() ├─ alloc_ordered_workqueue() //创建总线事件工作队列 ├─ kobject_init() //初始化总线kobject内核对象 ├─ klist_init() //初始化设备链表、驱动链表 ├─ subsystem_register() //注册总线子系统，创建sysfs总线目录 ├─ bus_create_file() //创建总线sysfs属性文件 └─ kset_register() //注册kset，管理总线子节点 五、链表引用计数核心知识点 1. klist_devices设备链表：传入get/put引用计数函数 取出节点自动增加设备引用计数，用完节点自动减少引用计数，保证操作时设备不会被销毁，支持安全增删改查遍历 2. klist_drivers驱动链表：传入NULL、NULL无引用计数函数 无法对驱动节点做引用保护，遍历操作会出现野指针崩溃风险，内核直接禁止一切增删改查操作，仅可静态记录驱动列表 六、总线注册完成后的作用 1. 内核拥有了该总线的完整管理框架 2. 总线可以接收device_register()注册的设备挂载 3. 总线可以接收driver_register()注册的驱动挂载 4. 总线match函数可以自动完成设备和驱动的匹配 5. 匹配成功后执行驱动probe初始化硬件 6. sysfs生成完整总线目录结构，用户态可查看总线、设备、驱动信息 七、总结 bus_register()是Linux总线驱动的基础入口函数，完整完成总线内核对象初始化、管理链表搭建、sysfs目录创建、设备驱动管理框架构建，是设备模型总线-设备-驱动三层结构的基础。

platform总线注册流程实例分析

platform总线注册流程实例分析 一、概述 platform总线是Linux虚拟总线，管理无物理总线的设备（LED、按键、LCD等）。 由内核启动自动调用platform_bus_init()完成注册。 二、核心注册函数 int __init platform_bus_init(void) { int err; err = bus_register(&platform_bus_type); platform_devpool_init(); return err; } 三、核心结构体platform_bus_type struct bus_type platform_bus_type = { .name = "platform", .match = platform_match, .probe = platform_bus_probe, .remove = platform_bus_remove, .shutdown = platform_bus_shutdown, .pm = &platform_dev_pm_ops, }; 四、注册流程步骤 1. 内核启动调用platform_bus_init() 2. 调用bus_register(&platform_bus_type)注册总线 3. 分配总线私有数据，包含kobject、设备链表、驱动链表 4. 初始化klist_devices（带引用计数，可操作） 5. 初始化klist_drivers（无引用计数，不可操作） 6. 初始化总线互斥锁 7. 初始化总线kobject，创建sysfs目录 8. 创建/sys/bus/platform/、devices、drivers目录 9. 绑定platform_match匹配函数 10. 执行platform_devpool_init()注册设备号 11. 注册完成，返回0 五、关键函数调用 platform_bus_init() → bus_register() → 链表初始化 → kobject初始化 → sysfs创建 六、注册成功效果 1. 生成/sys/bus/platform目录结构 2. 可注册platform_device和platform_driver 3. 自动匹配设备与驱动 4. 匹配成功执行驱动probe 七、总结 platform总线是虚拟总线，内核启动自动注册。 注册完成链表、kobject、sysfs、匹配函数，是平台设备驱动模型的基础。

在总线下注册设备

因为两个实验分开写的，所以你要导出上个实验的你自定义的总线类型

EXPORT_SYMBOL_GPL(mybus); //新加导出总线符号

extern struct bus_type mybus; // 定义一个设备释放函数（必须实现，否则内核崩溃） void myrelease(struct device *dev) { printk("设备释放\n"); } // 定义一个设备结构体 struct device mydevice = { .init_name = "mydevice", // 1. 设备名称（会出现在/sys/devices/xxx） .bus = &mybus, // 2. 设备挂载到哪条总线上 .release = myrelease, // 3. 设备释放回调函数（必须实现！） .devt = MKDEV(255, 100), // 4. 设备号：主设备号255，次设备号0（MKDEV是标准宏） }; // 模块初始化函数 static int device_init(void) { int ret; // 注册设备到内核设备模型 ret = device_register(&mydevice); // 注册失败必须返回错误码（你原来直接return 0是错的） if (ret) { printk("设备注册失败\n"); return ret; } return 0; }

device_register(struct device* dev)函数

int device_register(struct device* dev) { device_initialize(dev); return device_add(dev); } EXPORT_SYMBOL_GPL(device_register);

//数据结构初始化，属性文件初始化，添加软链接 void device_initialize(struct device* dev) { dev->kobj.kset=devices_kset; //关联全局设备集合 kobject_init(&dev->kobj,&device_ktype);//初始化内核对象，绑定设备释放 ... }

初始化链表，把设备加入到链表

platform_device_register(struct platform_device* pdev)函数

int platform_device_register(struct platform_device* pdev) { device_initialize(&pdev->dev); // arch_setup_pdev_archdata(pdev); return platform_device_add(pdev); }

步骤1：检查设备基本信息 + 设置默认父设备

核心代码逻辑：

if (!pdev) return -EINVAL; // 检查pdev指针是否为空（合法性校验） if (!pdev->dev.parent) pdev->dev.parent = &platform_bus; // 无父设备则默认指向platform_bus

关键作用：确保设备指针合法；统一所有平台设备的父设备，为sysfs节点统一路径（/sys/devices/platform）打下基础。

步骤2：设置设备总线类型

核心代码逻辑：

pdev->dev.bus = &platform_bus_type; // 将设备挂载到platform总线上

关键作用：告知内核该设备是“平台总线设备”，后续将走platform总线的驱动匹配逻辑。

步骤3：设置设备名称（3种格式）

核心代码逻辑（switch分支）：

• 默认（正常ID）：dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id) → 格式：name.id

• PLATFORM_DEVID_NONE（无ID）：dev_set_name(&pdev->dev, "%s", pdev->name) → 格式：仅name

• PLATFORM_DEVID_AUTO（自动分配ID）：ida_simple_get获取ID，格式：name.id.auto

关键作用：保证设备名唯一，避免sysfs节点冲突，便于内核识别和管理设备。

步骤4：添加设备资源（内存/IO等）

核心代码逻辑：

for (i = 0; i < pdev->num_resources; i++) { struct resource *r = &pdev->resource[i]; if (!r->name) r->name = dev_name(&pdev->dev); // 资源无名则用设备名 // 按资源类型（内存/IO）设置默认父资源，插入资源树避免冲突 if (resource_type(r) == IORESOURCE_MEM) p = &iomem_resource; if (resource_type(r) == IORESOURCE_IO) p = &ioport_resource; if (p && insert_resource(p, r)) return -EBUSY; }

关键作用：登记设备的硬件资源（如内存地址、IO端口），避免资源冲突，为后续驱动操作硬件提供依据。

步骤5：注册到内核设备模型 + 触发驱动匹配

核心代码逻辑：

ret = device_add(&pdev->dev); // 将设备加入内核设备模型 if (ret == 0) return ret;

关键补充：device_add() 内部会调用 bus_probe_device()，触发platform总线的驱动匹配逻辑，匹配成功则执行驱动的probe函数。

核心总结

流程闭环：检查合法性 → 设父设备 → 挂平台总线 → 设唯一设备名 → 登记资源 → 内核注册+驱动匹配，完成平台设备的完整注册。

为什么注册platform总线之前先注册设备

platform_bus_init() { // 第一步：注册 platform_bus 设备 → 先创建 /sys/devices/platform device_register(&platform_bus); // 第二步：注册 platform_bus_type 总线 → 让总线可以管理设备 bus_register(&platform_bus_type); }

应为总线上的设备必须要有一个父设备来管理这些设备，所以先创建一个父设备，

就是说，当通过platform_device_register()注册设备时，其dev.parent 会默认设置为 &platform_bus。platform_bus 设备注册后，会在 sysfs 中创建/sys/devices/platform 目录，所有 平台设备的sysfs节点都会在/sys/devices/platform 下创建子目录，所以在platform_bus_init()中 先注册设备后注册总线的顺序，目的是先构建platform顶层目录

在自己的总线下注册驱动

// 定义驱动结构体 struct device_driver mydriver = { .name = "mydevice", // 驱动名称（和设备名匹配用） .bus = &mybus, // 驱动属于哪条总线 .probe = mydriver_probe, // 匹配成功后调用的探测函数 .remove = mydriver_remove, // 卸载驱动时调用 }; // 模块初始化函数 static int mydriver_init(void) { int ret; ret = driver_register(&mydriver); // 注册驱动到内核 return ret; // 返回注册结果 }