Back to Details

device-drivers

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese

Device Drivers

Linux设备驱动

Purpose

用途

Guide agents through Linux kernel device driver development: the driver model (
platform_driver
, 
i2c_driver
, 
spi_driver
), character device lifecycle, IRQ handling including threaded IRQs, DMA engine API, regmap for register abstraction, runtime power management, and udev rules for userspace device nodes.
指导开发者完成Linux内核设备驱动开发：包括驱动模型（
platform_driver
、
i2c_driver
、
spi_driver
）、字符设备生命周期、包含线程化IRQ的中断处理、DMA引擎API、用于寄存器抽象的regmap、运行时电源管理，以及用于用户空间设备节点的udev规则。

When to Use

使用场景

  • Writing a platform driver for memory-mapped hardware
  • Implementing a character device with read/write/ioctl
  • Handling hardware interrupts (hard IRQ vs threaded)
  • Setting up DMA coherent or streaming mappings
  • Abstracting register access with regmap
  • Configuring udev rules for 
    /dev
    node permissions
  • 为内存映射硬件编写platform驱动
  • 实现包含read/write/ioctl的字符设备
  • 处理硬件中断（硬IRQ vs 线程化IRQ）
  • 设置DMA一致性或流式映射
  • 使用regmap抽象寄存器访问
  • 配置udev规则以设置
    /dev
    节点权限

Workflow

工作流程

1. Driver model overview

1. 驱动模型概述

Device tree / ACPI → bus (platform, i2c, spi, pci)
    → struct device → struct device_driver
        → probe() / remove()
c
// platform_driver.c — minimal platform driver
#include <linux/module.h>
#include <linux/platform_device.h>

static int my_probe(struct platform_device *pdev)
{
    struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    void __iomem *base = devm_ioremap_resource(&pdev->dev, res);
    if (IS_ERR(base))
        return PTR_ERR(base);
    dev_info(&pdev->dev, "probed at %pa\n", &res->start);
    return 0;
}

static void my_remove(struct platform_device *pdev)
{
    dev_info(&pdev->dev, "removed\n");
}

static struct platform_driver my_driver = {
    .probe  = my_probe,
    .remove = my_remove,
    .driver = { .name = "my-device", .owner = THIS_MODULE },
};

module_platform_driver(my_driver);
MODULE_LICENSE("GPL");
Device tree / ACPI → bus (platform, i2c, spi, pci)
    → struct device → struct device_driver
        → probe() / remove()
c
// platform_driver.c — 最小化platform驱动
#include <linux/module.h>
#include <linux/platform_device.h>

static int my_probe(struct platform_device *pdev)
{
    struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    void __iomem *base = devm_ioremap_resource(&pdev->dev, res);
    if (IS_ERR(base))
        return PTR_ERR(base);
    dev_info(&pdev->dev, "probed at %pa\n", &res->start);
    return 0;
}

static void my_remove(struct platform_device *pdev)
{
    dev_info(&pdev->dev, "removed\n");
}

static struct platform_driver my_driver = {
    .probe  = my_probe,
    .remove = my_remove,
    .driver = { .name = "my-device", .owner = THIS_MODULE },
};

module_platform_driver(my_driver);
MODULE_LICENSE("GPL");

2. Character device lifecycle

2. 字符设备生命周期

c
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>

#define DEVICE_NAME "mydev"
#define MINOR_BASE  0
#define MINOR_COUNT 1

static dev_t dev_num;
static struct cdev my_cdev;
static struct class *dev_class;

static ssize_t my_read(struct file *filp, char __user *buf,
                       size_t count, loff_t *ppos)
{
    char kbuf[64] = "hello from kernel\n";
    size_t len = strlen(kbuf);
    if (*ppos >= len)
        return 0;
    if (count > len - *ppos)
        count = len - *ppos;
    if (copy_to_user(buf, kbuf + *ppos, count))
        return -EFAULT;
    *ppos += count;
    return count;
}

static const struct file_operations my_fops = {
    .owner = THIS_MODULE,
    .read  = my_read,
};

static int __init mydev_init(void)
{
    int ret;
    ret = alloc_chrdev_region(&dev_num, MINOR_BASE, MINOR_COUNT, DEVICE_NAME);
    if (ret)
        return ret;

    cdev_init(&my_cdev, &my_fops);
    my_cdev.owner = THIS_MODULE;
    ret = cdev_add(&my_cdev, dev_num, MINOR_COUNT);
    if (ret)
        goto err_cdev;

    dev_class = class_create(DEVICE_NAME);
    device_create(dev_class, NULL, dev_num, NULL, DEVICE_NAME);
    return 0;

err_cdev:
    unregister_chrdev_region(dev_num, MINOR_COUNT);
    return ret;
}
bash
undefined
c
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>

#define DEVICE_NAME "mydev"
#define MINOR_BASE  0
#define MINOR_COUNT 1

static dev_t dev_num;
static struct cdev my_cdev;
static struct class *dev_class;

static ssize_t my_read(struct file *filp, char __user *buf,
                       size_t count, loff_t *ppos)
{
    char kbuf[64] = "hello from kernel\n";
    size_t len = strlen(kbuf);
    if (*ppos >= len)
        return 0;
    if (count > len - *ppos)
        count = len - *ppos;
    if (copy_to_user(buf, kbuf + *ppos, count))
        return -EFAULT;
    *ppos += count;
    return count;
}

static const struct file_operations my_fops = {
    .owner = THIS_MODULE,
    .read  = my_read,
};

static int __init mydev_init(void)
{
    int ret;
    ret = alloc_chrdev_region(&dev_num, MINOR_BASE, MINOR_COUNT, DEVICE_NAME);
    if (ret)
        return ret;

    cdev_init(&my_cdev, &my_fops);
    my_cdev.owner = THIS_MODULE;
    ret = cdev_add(&my_cdev, dev_num, MINOR_COUNT);
    if (ret)
        goto err_cdev;

    dev_class = class_create(DEVICE_NAME);
    device_create(dev_class, NULL, dev_num, NULL, DEVICE_NAME);
    return 0;

err_cdev:
    unregister_chrdev_region(dev_num, MINOR_COUNT);
    return ret;
}
bash
undefined

After loading module

加载模块后

ls -l /dev/mydev cat /dev/mydev
undefined
ls -l /dev/mydev cat /dev/mydev
undefined

3. IRQ handling

3. IRQ处理

c
#include <linux/interrupt.h>

static irqreturn_t my_hardirq(int irq, void *dev_id)
{
    // Minimal work: acknowledge, schedule bottom half
    return IRQ_WAKE_THREAD;
}

static irqreturn_t my_threaded(int irq, void *dev_id)
{
    // Process data — can sleep
    process_ring_buffer();
    return IRQ_HANDLED;
}

static int request_device_irq(struct device *dev, int irq)
{
    return devm_request_threaded_irq(dev, irq, my_hardirq, my_threaded,
                                     IRQF_ONESHOT, "mydev", dev);
}
PatternUse when
Hard IRQ onlyMicrosecond work, no blocking
Threaded IRQI2C/SPI reads, scheduling, mutex
IRQF_ONESHOT
Level-triggered; IRQ masked until threaded handler returns
c
#include <linux/interrupt.h>

static irqreturn_t my_hardirq(int irq, void *dev_id)
{
    // 最小化工作：确认中断，调度下半部
    return IRQ_WAKE_THREAD;
}

static irqreturn_t my_threaded(int irq, void *dev_id)
{
    // 处理数据 — 可休眠
    process_ring_buffer();
    return IRQ_HANDLED;
}

static int request_device_irq(struct device *dev, int irq)
{
    return devm_request_threaded_irq(dev, irq, my_hardirq, my_threaded,
                                     IRQF_ONESHOT, "mydev", dev);
}
模式使用场景
仅硬IRQ微秒级工作，无阻塞
线程化IRQI2C/SPI读取、调度、互斥锁
IRQF_ONESHOT
电平触发；线程化处理程序返回前IRQ被屏蔽

4. DMA engine API

4. DMA引擎API

c
#include <linux/dma-mapping.h>

// Coherent (consistent) mapping — CPU and device see same memory
void *cpu_addr;
dma_addr_t dma_handle;
cpu_addr = dma_alloc_coherent(dev, size, &dma_handle, GFP_KERNEL);

// Streaming (single) mapping for already-allocated buffers
dma_addr_t dma = dma_map_single(dev, kernel_buf, size, DMA_TO_DEVICE);
dma_sync_single_for_device(dev, dma, size, DMA_TO_DEVICE);
// ... device reads ...
dma_unmap_single(dev, dma, size, DMA_TO_DEVICE);
bash
undefined
c
#include <linux/dma-mapping.h>

// 一致性映射 — CPU和设备看到相同内存
void *cpu_addr;
dma_addr_t dma_handle;
cpu_addr = dma_alloc_coherent(dev, size, &dma_handle, GFP_KERNEL);

// 流式映射用于已分配的缓冲区
dma_addr_t dma = dma_map_single(dev, kernel_buf, size, DMA_TO_DEVICE);
dma_sync_single_for_device(dev, dma, size, DMA_TO_DEVICE);
// ... 设备读取 ...
dma_unmap_single(dev, dma, size, DMA_TO_DEVICE);
bash
undefined

Debug DMA mappings

调试DMA映射

cat /sys/kernel/debug/dma_buf/bufinfo 2>/dev/null
undefined
cat /sys/kernel/debug/dma_buf/bufinfo 2>/dev/null
undefined

5. regmap abstraction

5. regmap抽象

c
#include <linux/regmap.h>

static const struct regmap_config my_regmap_config = {
    .reg_bits   = 8,
    .val_bits   = 8,
    .max_register = 0xFF,
};

// I2C regmap (typical for sensors)
static struct regmap *regmap;

regmap_write(regmap, 0x01, 0x80);  // set config register
regmap_read(regmap, 0x02, &val);   // read status
regmap_update_bits(regmap, 0x03, MASK, VALUE);
regmap handles locking, caching, and bulk access — prefer over raw 
i2c_smbus_*
in new drivers.
c
#include <linux/regmap.h>

static const struct regmap_config my_regmap_config = {
    .reg_bits   = 8,
    .val_bits   = 8,
    .max_register = 0xFF,
};

// I2C regmap（传感器常用）
static struct regmap *regmap;

regmap_write(regmap, 0x01, 0x80);  // 设置配置寄存器
regmap_read(regmap, 0x02, &val);   // 读取状态
regmap_update_bits(regmap, 0x03, MASK, VALUE);
regmap处理锁、缓存和批量访问 — 在新驱动中优先使用，而非原生
i2c_smbus_*
接口。

6. Power management

6. 电源管理

c
#include <linux/pm_runtime.h>

static int my_runtime_suspend(struct device *dev)
{
    // Gate clocks, put hardware in low-power state
    return 0;
}

static int my_runtime_resume(struct device *dev)
{
    // Restore registers, enable clocks
    return 0;
}

static const struct dev_pm_ops my_pm_ops = {
    .runtime_suspend = my_runtime_suspend,
    .runtime_resume  = my_runtime_resume,
};

// In probe:
pm_runtime_enable(&pdev->dev);
pm_runtime_get_sync(&pdev->dev);  // ensure powered on
c
#include <linux/pm_runtime.h>

static int my_runtime_suspend(struct device *dev)
{
    // 关闭时钟，将硬件置于低功耗状态
    return 0;
}

static int my_runtime_resume(struct device *dev)
{
    // 恢复寄存器配置，启用时钟
    return 0;
}

static const struct dev_pm_ops my_pm_ops = {
    .runtime_suspend = my_runtime_suspend,
    .runtime_resume  = my_runtime_resume,
};

// 在probe函数中：
pm_runtime_enable(&pdev->dev);
pm_runtime_get_sync(&pdev->dev);  // 确保设备处于上电状态

7. udev rules

7. udev规则

bash
undefined
bash
undefined

/etc/udev/rules.d/99-mydev.rules

/etc/udev/rules.d/99-mydev.rules

KERNEL=="mydev", MODE="0666", GROUP="plugdev" SUBSYSTEM=="i2c-dev", KERNEL=="i2c-1", GROUP="i2c", MODE="0660"

```bash
sudo udevadm control --reload-rules
sudo udevadm trigger
udevadm info -a -n /dev/mydev
KERNEL=="mydev", MODE="0666", GROUP="plugdev" SUBSYSTEM=="i2c-dev", KERNEL=="i2c-1", GROUP="i2c", MODE="0660"

```bash
sudo udevadm control --reload-rules
sudo udevadm trigger
udevadm info -a -n /dev/mydev

8. I2C and SPI driver stubs

8. I2C和SPI驱动框架

c
// i2c_driver
static const struct i2c_device_id my_i2c_id[] = {
    { "sensor-chip", 0 },
    { }
};
MODULE_DEVICE_TABLE(i2c, my_i2c_id);

static struct i2c_driver my_i2c_driver = {
    .driver = { .name = "sensor-chip" },
    .probe  = my_i2c_probe,
    .remove = my_i2c_remove,
    .id_table = my_i2c_id,
};
module_i2c_driver(my_i2c_driver);
c
// i2c_driver
static const struct i2c_device_id my_i2c_id[] = {
    { "sensor-chip", 0 },
    { }
};
MODULE_DEVICE_TABLE(i2c, my_i2c_id);

static struct i2c_driver my_i2c_driver = {
    .driver = { .name = "sensor-chip" },
    .probe  = my_i2c_probe,
    .remove = my_i2c_remove,
    .id_table = my_i2c_id,
};
module_i2c_driver(my_i2c_driver);

Common Problems

常见问题

SymptomCauseFix
probe failed with -EBUSY
Resource conflict or double probeCheck device tree 
status
; 
devm_*
cleanup
IRQ stormMissing acknowledge in handlerACK interrupt in hardirq; use 
IRQF_ONESHOT
DMA coherency bugWrong sync direction
dma_sync_single_for_cpu/device
at boundaries
/dev/node
missing		class_create/device_create failedCheck 
dmesg
; verify 
cdev_add
return
copy_to_user
fault		Invalid userspace pointerValidate with 
access_ok
Runtime PM hangMissing 
pm_runtime_put
Balance get/put; use 
devm_pm_runtime_enable
症状原因解决方法
probe failed with -EBUSY
资源冲突或重复探测检查设备树
status
；使用
devm_*
自动清理
IRQ风暴处理程序中未确认中断在硬IRQ中确认中断；使用
IRQF_ONESHOT
DMA一致性问题同步方向错误在边界处使用
dma_sync_single_for_cpu/device
/dev
节点缺失		class_create/device_create执行失败查看
dmesg
日志；验证
cdev_add
返回值
copy_to_user
错误		用户空间指针无效使用
access_ok
验证
运行时PM挂起缺少
pm_runtime_put
平衡get/put调用；使用
devm_pm_runtime_enable

Related Skills

相关技能

  • skills/kernel/kernel-internals
    — VFS, memory allocators underlying drivers
  • skills/low-level-programming/linux-kernel-modules
    — Kbuild, module loading, signing
  • skills/kernel/kernel-debugging
    — kgdb, ftrace for driver bugs
  • skills/embedded/zephyr
    — embedded RTOS driver model comparison
  • skills/observability/ebpf
    — trace driver events without modifying kernel
  • skills/kernel/kernel-testing
    — KUnit tests for driver logic
  • skills/kernel/kernel-internals
    — 驱动底层的VFS、内存分配器
  • skills/low-level-programming/linux-kernel-modules
    — Kbuild、模块加载、签名
  • skills/kernel/kernel-debugging
    — 使用kgdb、ftrace调试驱动bug
  • skills/embedded/zephyr
    — 嵌入式RTOS驱动模型对比
  • skills/observability/ebpf
    — 无需修改内核即可追踪驱动事件
  • skills/kernel/kernel-testing
    — 为驱动逻辑编写KUnit测试