概要性了解Linux的总线设备驱动

server/2025/1/11 22:24:00/

引言

假如我们的板子上有很多LED，有时候需要操作这个LED，有时候需要操作另一个LED，我们希望代码可以清晰地组织在一起，方便扩展，同时自动为这些具体的设备生成对应的设备文件以供用户空间使用。

在Linux中，可以通过总线设备驱动编程的方法来实现这个需求。

这种方法将驱动程序划分为三个部分：总线 (Bus)、设备 (Device) 和 驱动 (Driver)。

  • 设备: 代表具体的硬件资源，例如一个 LED，同时描述了它的相关硬件信息（如寄存器地址、IRQ 等）。
  • 驱动: 实现了操作该设备的具体逻辑代码。
  • 总线: 负责在设备和驱动之间建立匹配关系，并调用驱动程序对设备进行初始化。

匹配过程可以大致理解为：

  1. 设备代码: 告诉总线有哪些硬件资源需要被驱动。
  2. 总线程序: 根据设备的信息，去查找注册过的驱动程序中是否有能够匹配的驱动。
  3. 驱动程序: 被总线调用后完成设备的初始化，并通过内核 API 为用户空间创建对应的设备文件（如 /dev/led0），这样这些设备就可以被用户访问和使用了。

这种设计具有模块化、可扩展和动态加载的优点，适用于开发复杂的嵌入式系统。

总线设备驱动的相关基础知识

总线设备驱动编程方法是 Linux 驱动模型的重要组成部分。总线、设备和驱动是 Linux 设备模型的核心三大概念。以下是详细价绍：

1. 总线设备驱动的三个基本概念

总线设备驱动编程方法将系统中的硬件划分为三部分：总线 (Bus)、设备 (Device) 和 驱动 (Driver)，它们通过 Linux 的设备模型进行抽象和管理。

  • 总线 (Bus): 描述一类硬件连接标准（如 I2C、SPI、PCI 等），负责在设备和驱动之间建立匹配关系。
  • 设备 (Device): 表示挂载在某条总线上的具体硬件设备，通常由总线代码创建。
  • 驱动 (Driver): 用于操作某种特定设备的代码实现。

2. 总线设备驱动的结构

在 Linux 驱动模型中，设备和驱动通过总线进行联系，主要通过以下方式实现：

  • struct bus_type: 定义总线类型并实现其操作函数。
  • struct device: 定义具体的硬件设备。
  • struct device_driver: 定义设备驱动。
  • 匹配机制: 设备和驱动通过名字或其他标识符进行匹配，比如使用 id_table 或 of_match_table。

3. 总线设备驱动的实现步骤

以下是实现总线设备驱动的一般步骤：

1. 注册总线

实现和注册总线类型：

static struct bus_type my_bus_type = {.name = "my_bus",.match = my_bus_match, // 匹配函数.probe = my_bus_probe, // 设备绑定驱动时调用.remove = my_bus_remove, // 解绑时调用
};
bus_register(&my_bus_type);

2. 注册设备

创建并注册设备：

static struct device my_device = {.init_name = "my_device",.bus = &my_bus_type,
};
device_register(&my_device);

3. 注册驱动

创建并注册驱动：

static struct device_driver my_driver = {.name = "my_device", // 必须与设备名字一致.bus = &my_bus_type,
};
driver_register(&my_driver);

4. 匹配设备和驱动

设备和驱动通过总线的 match 函数匹配，一旦匹配成功，就会调用 probe 函数进行初始化。

4. 设备树支持

如果硬件通过设备树描述，总线和设备的关联通常由 of_match_table 或 acpi_match_table 提供，匹配更加自动化。

5. 总线设备驱动的优点

  • 模块化设计: 硬件抽象更清晰，设备和驱动可以独立开发。
  • 动态管理: 支持动态加载和卸载设备及驱动。
  • 通用性强: 可以适配不同的总线类型。

常见的符合Linux标准的总线设备驱动

符合Linux标准的总线设备驱动被称为标准总线设备驱动 ，以下是常见的 标准总线设备驱动 以及它们的介绍：

1. Platform 总线设备驱动

简介
  • Platform 总线 是一个虚拟的、与硬件无关的总线，主要用于管理 片上系统 (SoC) 上的设备。
  • 适合处理没有明确硬件总线（如 I2C、SPI 等）约束的设备，比如板载 LED、GPIO、按键等。
组成
  • 设备：用 struct platform_device 描述，表示具体硬件资源。
  • 驱动：用 struct platform_driver 描述，实现对硬件的具体操作。
设备与驱动的匹配
  • 匹配基于设备名称（platform_device.name 和 platform_driver.name）。
  • 注册函数：platform_device_register() 和 platform_driver_register()。
特点
  • 简单易用，适用于自定义硬件资源的管理。
  • 常用于嵌入式开发，特别是 SoC 内部的设备。
示例
// 注册一个设备
static struct platform_device my_device = {.name = "my_platform_device",.id = -1,
};
platform_device_register(&my_device);// 编写对应的驱动
static int my_probe(struct platform_device *pdev) {printk("Device probed: %s\n", pdev->name);return 0;
}static struct platform_driver my_driver = {.driver = {.name = "my_platform_device",},.probe = my_probe,
};
platform_driver_register(&my_driver);

2. I2C 总线设备驱动

简介
  • I2C 总线 是一种串行总线，用于连接低速设备（如 EEPROM、传感器、RTC 等）。
  • Linux 内核为 I2C 总线提供了完整的驱动框架。
组成
  • 设备：用 struct i2c_client 描述，表示连接到 I2C 总线的设备。
  • 驱动：用 struct i2c_driver 描述，实现设备的操作逻辑。
  • 总线：用 struct i2c_adapter 描述，表示 I2C 控制器。
设备与驱动的匹配
  • 匹配基于设备名称（i2c_client.name 和 i2c_driver.id_table）。
  • 注册函数：i2c_new_device() 和 i2c_add_driver()。
特点
  • 适合驱动所有通过 I2C 总线连接的设备。
  • 支持通过设备树或平台数据描述设备。
示例
// 定义 I2C 驱动
static int my_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) {printk("I2C device probed: %s\n", client->name);return 0;
}static struct i2c_driver my_driver = {.driver = {.name = "my_i2c_device",},.probe = my_i2c_probe,.id_table = (struct i2c_device_id[]) {{ "my_i2c_device", 0 },{ }},
};
i2c_add_driver(&my_driver);

3. SPI 总线设备驱动

简介
  • SPI 总线 是一种高速的全双工串行总线，用于连接设备如 SPI 闪存、显示屏、传感器等。
  • Linux 内核为 SPI 总线提供了通用的驱动框架。
组成
  • 设备：用 struct spi_device 描述，表示挂载到 SPI 总线的设备。
  • 驱动：用 struct spi_driver 描述，实现设备的操作逻辑。
  • 总线：用 struct spi_master 描述，表示 SPI 控制器。
设备与驱动的匹配
  • 匹配基于设备名称（spi_device.name 和 spi_driver.driver.name）。
  • 注册函数：spi_register_device() 和 spi_register_driver()。
特点
  • 提供对 SPI 总线的完整支持，适合驱动各种 SPI 外设。
  • 支持通过设备树或平台数据描述设备。
示例
// 定义 SPI 驱动
static int my_spi_probe(struct spi_device *spi) {printk("SPI device probed: %s\n", spi->modalias);return 0;
}static struct spi_driver my_driver = {.driver = {.name = "my_spi_device",},.probe = my_spi_probe,
};
spi_register_driver(&my_driver);

4. USB 驱动

简介
  • USB 总线 是一种常见的高速串行总线，用于连接外设如键盘、鼠标、存储设备等。
  • Linux 提供了完整的 USB 驱动模型。
组成
  • 设备：用 struct usb_device 描述，表示 USB 总线上的设备。
  • 驱动：用 struct usb_driver 描述，实现对设备的操作逻辑。
  • 总线：USB 控制器实现了 USB 总线管理。
设备与驱动的匹配
  • 匹配基于设备的 Vendor ID 和 Product ID。
  • 注册函数：usb_register_driver()。
特点
  • 支持所有标准 USB 设备协议。
  • 提供 USB 核心模块，用于设备的管理和匹配。
示例
// 定义 USB 驱动
static int my_usb_probe(struct usb_interface *interface, const struct usb_device_id *id) {printk("USB device probed\n");return 0;
}static struct usb_device_id my_usb_table[] = {{ USB_DEVICE(0x1234, 0x5678) },{ }
};static struct usb_driver my_driver = {.name = "my_usb_device",.probe = my_usb_probe,.id_table = my_usb_table,
};
usb_register_driver(&my_driver);

5. PCI 驱动

简介
  • PCI 总线 是一种高速并行总线，用于连接设备如网卡、显卡等。
  • Linux 内核为 PCI 提供了标准的驱动框架。
组成
  • 设备：用 struct pci_dev 描述，表示 PCI 总线上的设备。
  • 驱动：用 struct pci_driver 描述，实现设备的操作逻辑。
设备与驱动的匹配
  • 匹配基于设备的 Vendor ID 和 Device ID。
  • 注册函数：pci_register_driver()。
特点
  • 支持标准的 PCI 协议，适合驱动各种 PCI 设备。
  • 提供内核接口简化驱动开发。
示例
// 定义 PCI 驱动
static int my_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) {printk("PCI device probed\n");return 0;
}static struct pci_device_id my_pci_table[] = {{ PCI_DEVICE(0x1234, 0x5678) },{ }
};static struct pci_driver my_driver = {.name = "my_pci_device",.id_table = my_pci_table,.probe = my_pci_probe,
};
pci_register_driver(&my_driver);

总结

这些标准总线设备驱动都依赖 Linux 内核的驱动模型，统一了设备与驱动的管理方式，极大地简化了驱动开发工作：

  • Platform 总线设备驱动：用于片上资源。
  • I2C 和 SPI 驱动：用于串行总线设备。
  • USB 驱动：用于外部高速设备。
  • PCI 驱动：用于高速并行设备。

它们的核心思想相同，只是针对不同的总线和设备提供了不同的实现。

Linux源码中提供的与I2C有关的总线设备驱动有什么用？

问：Linux源码中提供的与I2C有关的总线设备驱动有什么用，比如drivers\nfc\nfcmrvl\i2c.c，我实际在驱动一个I2C时还是得去写驱动程序呀？我能不能借助这些文件填个I2C的设备信息就完成了I2C设备的驱动？

答：Linux 源代码中像 drivers/nfc/nfcmrvl/i2c.c 这样的文件，确实是与 I2C 驱动相关的代码。它们的作用是为某些具体的 I2C 设备提供驱动程序实现。但在实际开发中，是否需要完全自行编写驱动程序，或者能否借助现有代码和框架，取决于具体设备和使用场景。以下是详细的说明：

1. 源代码中的 I2C 驱动文件的作用

像 drivers/nfc/nfcmrvl/i2c.c 这样的文件，是为特定的 I2C 外设 提供驱动实现。例如：

  • nfcmrvl 是一个 NFC 控制器的驱动程序，i2c.c 实现了通过 I2C 总线与硬件交互的功能。
  • 它的核心作用是：
    • 提供 probe 函数来初始化设备，配置寄存器。
    • 实现设备的操作逻辑（如读写数据、状态监控）。
    • 与 Linux 内核的 I2C 子系统协作，通过注册 i2c_driver 和设备匹配。

这些驱动文件是为具体硬件提供的参考实现，如果你的硬件设备刚好是类似的设备，可能可以直接使用或稍加改动就能满足需求。

2. 是否需要自己写驱动程序？

这取决于你的硬件设备是否已经有现成的驱动支持，或者是否可以使用通用驱动。

(1) 硬件有现成驱动支持

  • 如果你的 I2C 设备已经有厂商提供的驱动，或者 Linux 内核中已经有现成的驱动（比如像 drivers/nfc/nfcmrvl/i2c.c），你只需要：

    • 注册设备：通过设备树（Device Tree）或平台数据将设备信息传递给驱动。
    • 加载驱动：在内核中启用或加载相应的模块。

  • 示例：如果你使用的设备是一个支持 I2C 接口的 EEPROM 芯片（比如 AT24 系列），Linux 内核中已经有通用的 at24 驱动，你只需要在设备树中描述硬件信息：

    i2c1: i2c@1 {eeprom@50 {compatible = "atmel,24c02";reg = <0x50>;};
};

    然后加载 at24 模块即可完成设备驱动，无需自己编写驱动程序。

(2) 硬件没有现成驱动支持
  • 如果你的设备是定制的，或者没有现成驱动，就需要自己编写驱动程序。
  • 不过，Linux 内核已经为 I2C 总线提供了完整的框架：
    • 你只需实现设备的特定逻辑（如寄存器配置、数据读写等）。
    • 借助内核的 I2C 框架，可以大幅简化驱动开发。

示例代码框架：

static int my_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{// 设备初始化printk(KERN_INFO "Probing I2C device: %s\n", client->name);return 0;
}static int my_i2c_remove(struct i2c_client *client)
{// 设备卸载printk(KERN_INFO "Removing I2C device: %s\n", client->name);return 0;
}static const struct i2c_device_id my_i2c_id[] = {{ "my_device", 0 },{ }
};static struct i2c_driver my_i2c_driver = {.driver = {.name = "my_device",},.probe = my_i2c_probe,.remove = my_i2c_remove,.id_table = my_i2c_id,
};module_i2c_driver(my_i2c_driver);

3. 能否只填设备信息完成 I2C 设备驱动？

在某些情况下，确实可以，具体情况如下：

(1) 使用通用驱动
  • 如果设备只需要简单的读写操作（如 EEPROM、GPIO 扩展芯片等），Linux 已提供一些通用驱动，可以通过设备树或平台代码传递设备信息。
  • 示例：
    • at24 驱动支持 I2C EEPROM。
    • gpio-mcp23s08 驱动支持 I2C GPIO 扩展芯片。

你只需提供设备树信息，无需自己编写驱动程序。

(2) 自定义硬件逻辑
  • 如果硬件逻辑很复杂，比如需要进行协议栈解析、状态管理等，那么仅靠设备信息无法满足需求，仍需编写驱动程序。

4. 借助现有代码的可能性

如果现有驱动（如 drivers/nfc/nfcmrvl/i2c.c）与目标设备逻辑类似，可以：

  1. 参考现有代码：根据目标设备特性修改现有代码（如修改设备初始化、寄存器操作等）。
  2. 作为模板实现新驱动：通过复用现有驱动框架，减少开发工作量。

小结

  • Linux 源代码中 drivers/.../i2c.c 文件是为具体的 I2C 设备提供的驱动实现，它们遵循总线设备驱动模型，主要作用是控制对应硬件。
  • 如果你的硬件设备已经有现成驱动，可以直接使用或稍作配置完成驱动加载。
  • 如果没有现成驱动，可以借助 I2C 框架编写自己的驱动程序。
  • 在某些简单设备场景下，只需填充设备信息（通过设备树或平台代码）即可完成设备驱动。

http://www.ppmy.cn/server/157593.html

相关文章

代理模式简介

代理模式简介

代理模式是一种设计模式&#xff0c;它允许我们通过一个中介对象来间接访问目标对象&#xff0c;这个中介对象称为“代理”。代理模式的关键在于&#xff0c;它在不改变目标对象代码的前提下&#xff0c;通过引入代理对象来增加额外的功能或控制对目标对象的访问。 代理模式的基…
阅读更多...
npm run 运行项目报错：Cannot resolve the ‘pnmp‘ package manager

npm run 运行项目报错：Cannot resolve the ‘pnmp‘ package manager

尝试使用 npm 运行一个项目&#xff0c;但是在解析 pnmp 包管理器时遇到了问题。这通常意味着项目可能配置错误&#xff0c;或者可能误输入了命令。 解决方法&#xff1a; 确认是否有拼写错误。通常情况下&#xff0c;应该是 npm 而不是 pnmp。 检查项目的 package.json 文件&…
阅读更多...
弹性云服务器和普通服务器的区别

弹性云服务器和普通服务器的区别

云服务器随着云计算的快速发展&#xff0c;也受到了各个企业的广泛使用&#xff0c;随着业务需求的不断变化&#xff0c;云服务器的类型也在不断进行细化&#xff0c;其中弹性云服务器逐渐受到企业的欢迎&#xff0c;那么弹性云服务器和普通服务器究竟有什么区别呢&#xff1f;…
阅读更多...
Linux内核 -- RTC 驱动的注册方式

Linux内核 -- RTC 驱动的注册方式

Linux 内核中 RTC 驱动的注册方式 在 Linux 内核中&#xff0c;RTC&#xff08;Real-Time Clock&#xff09;驱动的注册可以通过多种方式实现&#xff0c;以下整理了常见的注册方式及其注意事项。 1. 使用 devm_rtc_device_register 这是注册 RTC 驱动的最常用方法&#xff…
阅读更多...
将光源视角的深度贴图应用于摄像机视角的渲染

将光源视角的深度贴图应用于摄像机视角的渲染

将光源视角的深度贴图应用于摄像机视角的渲染是阴影映射&#xff08;Shadow Mapping&#xff09;技术的核心步骤之一。这个过程涉及到将摄像机视角下的片段坐标转换到光源视角下&#xff0c;并使用深度贴图来判断这些片段是否处于阴影中。 1. 生成光源视角的深度贴图 首先&…
阅读更多...
景芯SOC设计实战

景芯SOC设计实战

终身辅导、一对一辅导&#xff0c;手把手教您完成SoC全流程设计&#xff0c;从入门到进阶&#xff0c;带您掌握SoC芯片架构、算法、设计、验证、DFT、后端及低功耗全流程&#xff01;直播视频不定期升级&#xff01;让您快速超越同龄人&#xff01; 景芯团队主打文档服务器实战…
阅读更多...
Go语言中的接收器（Receiver）详解

Go语言中的接收器（Receiver）详解

在 Go 语言中&#xff0c;接收器&#xff08;Receiver&#xff09; 是指在方法声明中与方法绑定的对象。它是 Go 语言实现面向对象编程&#xff08;OOP&#xff09;特性的核心之一。接收器的作用是将方法绑定到某个类型的实例&#xff08;值或者指针&#xff09;&#xff0c;让…
阅读更多...
多租户架构是什么？

多租户架构是什么？

多租户架构&#xff08;Multi-Tenant Architecture&#xff09;是一种软件架构模型&#xff0c;在这种架构下&#xff0c;一个应用程序可以同时为多个不同的“租户”提供服务&#xff0c;每个租户的数据和设置是隔离的&#xff0c;但都共享同一份软件和硬件资源。每个租户可以视…
阅读更多...
最新文章

Copyright @ 2022~2023