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

引言

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

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

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

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

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

设备代码: 告诉总线有哪些硬件资源需要被驱动。
总线程序: 根据设备的信息，去查找注册过的驱动程序中是否有能够匹配的驱动。
驱动程序: 被总线调用后完成设备的初始化，并通过内核 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);