1
┌─────────────────────────────────────────────┐
2
│              用户空间 (User Space)            │
3
│  ┌──────┐  ┌──────┐  ┌──────┐              │
4
│  │ App1 │  │ App2 │  │ App3 │              │
5
│  └──┬───┘  └──┬───┘  └──┬───┘              │
6
│     │         │         │                    │
7
│     └────┬────┴────┬────┘                    │
8
│          │ open/read/write/ioctl             │
9
│          ▼ (系统调用, 陷入内核)              │
10
├──────────────────────────────────────────────┤
11
│              内核空间 (Kernel Space)          │
12
│  ┌───────────────────────────────┐           │
13
│  │      VFS (虚拟文件系统)       │           │
14
│  │  "一切皆文件"的统一接口       │           │
15
│  │  struct file_operations       │           │
22 collapsed lines
16
│  └───────────┬───────────────────┘           │
17
│              │                               │
18
│  ┌───────────┼───────────┬──────────┐        │
19
│  │           │           │          │        │
20
│  ▼           ▼           ▼          ▼        │
21
│ 字符设备   块设备     网络设备    其他       │
22
│ (串口/LED) (eMMC/SD) (eth/wifi) (USB/I2C)   │
23
│  ┌──────┐  ┌──────┐  ┌──────┐              │
24
│  │cdev  │  │gendisk│  │net_  │              │
25
│  │      │  │       │  │device│              │
26
│  └──┬───┘  └──┬───┘  └──┬───┘              │
27
│     │         │         │                    │
28
│  ┌──┴─────────┴─────────┴──┐                │
29
│  │     设备驱动模型          │                │
30
│  │  bus / device / driver   │                │
31
│  │  Platform / I2C / SPI    │                │
32
│  └──────────┬───────────────┘                │
33
│             │                                │
34
├─────────────┼────────────────────────────────┤
35
│   硬件      │                                │
36
│   GPIO / UART / SPI / I2C / DMA / 中断       │
37
└─────────────────────────────────────────────┘

1
// 字符设备驱动最小模板(必须背!)
2
#include <linux/module.h>
3
#include <linux/fs.h>
4
#include <linux/cdev.h>
5

6
static struct cdev my_cdev;
7
static dev_t dev_num;
8

9
// ① 定义 file_operations (连接用户空间和驱动)
10
static int my_open(struct inode *inode, struct file *file) { return 0; }
11
static ssize_t my_read(struct file *f, char __user *buf, size_t len, loff_t *off) {
12
    copy_to_user(buf, kernel_buf, len);  // 内核→用户(必须用copy_to_user)
13
    return len;
14
}
15
static struct file_operations my_fops = {
22 collapsed lines
16
    .owner = THIS_MODULE,
17
    .open  = my_open,
18
    .read  = my_read,
19
};
20

21
// ② 模块加载
22
static int __init my_init(void) {
23
    alloc_chrdev_region(&dev_num, 0, 1, "mydev");  // 动态分配设备号
24
    cdev_init(&my_cdev, &my_fops);                  // 绑定fops
25
    cdev_add(&my_cdev, dev_num, 1);                  // 注册到内核
26
    // class_create + device_create → 自动创建/dev节点
27
    return 0;
28
}
29

30
// ③ 模块卸载
31
static void __exit my_exit(void) {
32
    cdev_del(&my_cdev);
33
    unregister_chrdev_region(dev_num, 1);
34
}
35
module_init(my_init);
36
module_exit(my_exit);
37
MODULE_LICENSE("GPL");

1
为什么需要Platform模型？
2
  → 将"硬件信息"和"驱动逻辑"分离(解耦)
3
  → 硬件信息放设备树(.dts), 驱动逻辑放.c文件
4
  → 换一块板子只改设备树,驱动代码不用动!
5

6
设备树(.dts) → 编译 → .dtb → U-Boot传给内核
7

8
设备树示例:
9
  my_led {
10
      compatible = "mycompany,led";  ← ★匹配关键字
11
      reg = <0x40020000 0x400>;       ← 寄存器基地址
12
      gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>;
13
  };
14

15
驱动匹配流程:
14 collapsed lines
16
  ┌──────────┐        ┌──────────┐
17
  │ 设备树节点│        │Platform  │
18
  │compatible│        │Driver    │
19
  │= "xxx"   │        │.of_match │
20
  └────┬─────┘        │= "xxx"  │
21
       │               └────┬─────┘
22
       └──────┬──────────────┘
23
              ▼
24
         Platform Bus
25
         匹配成功! → 调用 probe()
26
         匹配失败  → 不调用
27

28
  ★ probe()时才真正初始化硬件(申请资源/注册设备)
29
  ★ remove()时释放资源

1
为什么要分两半？
2
  中断处理期间会屏蔽同级中断 → 必须极快退出!
3
  耗时操作(如读I2C传感器数据)不能在中断里做
4

5
  ┌──────────────┐  中断触发
6
  │  上半部       │  ← 硬中断,关中断状态
7
  │  (Top Half)  │  ← 只做: 读硬件状态 + 清中断标志
8
  │  极快(<微秒) │  ← schedule下半部
9
  └──────┬───────┘
10
         │ 延迟调度
11
         ▼
12
  ┌──────────────┐
13
  │  下半部       │  ← 开中断状态,可被打断
14
  │ (Bottom Half)│  ← 做: 数据处理、唤醒进程
15
  │  可以较慢    │
14 collapsed lines
16
  └──────────────┘
17

18
下半部实现方式:
19
  ┌──────────┬─────────┬─────────┬──────────────┐
20
  │          │softirq  │tasklet  │workqueue     │
21
  ├──────────┼─────────┼─────────┼──────────────┤
22
  │ 上下文   │ 软中断  │ 软中断  │ 进程(可睡眠)│
23
  │ 能睡眠？  │ 不能    │ 不能    │ 能 ★        │
24
  │ 并发     │ 可多CPU │ 同类不并│ 可多CPU      │
25
  │ 典型用途 │ 网络/块 │ 简单延迟│ I2C/SPI读写  │
26
  └──────────┴─────────┴─────────┴──────────────┘
27

28
  ★ 需要睡眠(如I2C读传感器) → 必须用 workqueue
29
  ★ 不需要睡眠的简单工作 → tasklet

1
#include <linux/init.h>
2
#include <linux/module.h>
3

4
static int __init my_init(void) {
5
    printk(KERN_INFO "Hello Kernel!\n");
6
    return 0;  /* 0 = 成功, 非零 = 失败 */
7
}
8

9
static void __exit my_exit(void) {
10
    printk(KERN_INFO "Bye Kernel!\n");
11
}
12

13
module_init(my_init);   /* 指定入口函数 */
14
module_exit(my_exit);   /* 指定出口函数 */
15
MODULE_LICENSE("GPL");  /* 必须声明许可证 */
2 collapsed lines
16
MODULE_AUTHOR("xxx");
17
MODULE_DESCRIPTION("demo module");

1
static int baud = 115200;
2
static char *name = "uart0";
3
module_param(baud, int, 0644);      /* 0644 = /sys/module/xxx/parameters/ 可读写 */
4
module_param(name, charp, 0444);
5
MODULE_PARM_DESC(baud, "Baud rate, default 115200");
6

7
/* 数组参数 */
8
static int arr[4];
9
static int arr_count;
10
module_param_array(arr, int, &arr_count, 0644);

1
KERN_EMERG   0   系统不可用
2
KERN_ALERT   1   需要立即动作
3
KERN_CRIT    2   严重条件
4
KERN_ERR     3   错误
5
KERN_WARNING 4   警告
6
KERN_NOTICE  5   正常但显著
7
KERN_INFO    6   信息
8
KERN_DEBUG   7   调试
9

10
/* 查看/设置当前打印级别 */
11
cat /proc/sys/kernel/printk
12
/* 输出: 4 4 1 7 → 当前/默认/最低控制台级别/默认控制台 */
13
echo 8 > /proc/sys/kernel/printk  /* 允许所有级别 */

1
┌─────────────────────────────────────┐ 4GB (32位)
2
│         内核空间 (1GB)              │ 3G~4G
3
│  所有进程共享同一份内核映射          │
4
├─────────────────────────────────────┤ 3GB
5
│         用户空间 (3GB)              │ 0~3G
6
│  每个进程独立的虚拟地址空间          │
7
└─────────────────────────────────────┘ 0
8

9
64位系统：用户空间 0~0x7FFFFFFFFFFF，内核空间 0xFFFF800000000000 以上

1
                    Linux驱动模型
2
        ┌──────────────┼──────────────┐
3
    字符设备         块设备         网络设备
4
    (char dev)      (block dev)    (net dev)
5
    │               │               │
6
    file_operations  request_queue   net_device_ops
7
    │               │               │
8
    LED/按键/串口    磁盘/SD卡/NAND   eth/wifi/can
9
    ADC/SPI/I2C     eMMC/NVMe

1
# 内核模块Makefile
2
obj-m += mymodule.o                    # 单文件模块
3
# obj-m += mydriver.o                  # 多文件模块
4
# mydriver-objs := file1.o file2.o
5

6
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
7
PWD := $(shell pwd)
8

9
all:
10
  $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
11

12
clean:
13
  $(MAKE) -C $(KERNELDIR) M=$(PWD) clean
14

15
# 交叉编译
2 collapsed lines
16
# KERNELDIR = /path/to/arm-kernel
17
# ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- make

1
#include <linux/version.h>
2

3
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 0, 0)
4
    // 5.0+的API
5
#else
6
    // 旧版API
7
#endif
8

9
// 常见变化:
10
// 4.x→5.x: access_ok()参数减少
11
// 5.6+: proc_ops替代file_operations
12
// 5.15+: class_create()参数减少

1
// GFP标志(分配位置/行为)
2
void *p = kmalloc(1024, GFP_KERNEL);  // 可睡眠(进程上下文)
3
void *p = kmalloc(1024, GFP_ATOMIC);  // 不可睡眠(中断上下文)
4
void *p = kzalloc(sizeof(struct mydev), GFP_KERNEL);
5

6
// 大块(>128KB)
7
void *p = vmalloc(1024 * 1024);  // 1MB
8
vfree(p);

1
#include <linux/list.h>
2

3
struct my_node {
4
    int data;
5
    struct list_head list;  // 嵌入链表节点
6
};
7

8
// 声明并初始化链表头
9
LIST_HEAD(my_list);
10

11
// 添加节点
12
struct my_node *node = kzalloc(sizeof(*node), GFP_KERNEL);
13
node->data = 42;
14
list_add(&node->list, &my_list);       // 头插
15
list_add_tail(&node->list, &my_list);  // 尾插
13 collapsed lines
16

17
// 遍历
18
struct my_node *pos;
19
list_for_each_entry(pos, &my_list, list) {
20
    printk("data = %d\n", pos->data);
21
}
22

23
// 安全遍历(可删除)
24
struct my_node *tmp;
25
list_for_each_entry_safe(pos, tmp, &my_list, list) {
26
    list_del(&pos->list);
27
    kfree(pos);
28
}

1
#define container_of(ptr, type, member) ({\
2
    const typeof(((type *)0)->member) *__mptr = (ptr);\
3
    (type *)((char *)__mptr - offsetof(type, member));})
4

5
// 原理: 成员地址 - 成员在结构体中的偏移 = 结构体首地址
6

7
// 使用场景(驱动中常见)
8
struct my_device {
9
    int id;
10
    struct cdev cdev;  // 字符设备
11
};
12

13
// 在file_operations中通过inode->i_cdev获取my_device
14
struct my_device *dev = container_of(inode->i_cdev, struct my_device, cdev);

1
// 错误指针: 将错误码编码到指针最高位
2
void *ptr = some_kernel_func();
3
if (IS_ERR(ptr)) {
4
    int err = PTR_ERR(ptr);
5
    printk("Error: %d\n", err);
6
    return err;
7
}
8

9
// 返回错误指针
10
struct device *create_device(...) {
11
    if (failed)
12
        return ERR_PTR(-ENOMEM);
13
    return dev;
14
}

1
#include <linux/workqueue.h>
2

3
// 方法1: 系统默认workqueue
4
struct work_struct my_work;
5

6
void work_handler(struct work_struct *work) {
7
    // 可以睡眠! 可以调用kmalloc(GFP_KERNEL)
8
    printk("Work executed\n");
9
}
10

11
INIT_WORK(&my_work, work_handler);
12
schedule_work(&my_work);  // 提交到系统workqueue
13

14
// 方法2: 延迟工作
15
struct delayed_work my_delayed_work;
2 collapsed lines
16
INIT_DELAYED_WORK(&my_delayed_work, work_handler);
17
schedule_delayed_work(&my_delayed_work, msecs_to_jiffies(1000));

1
#include <linux/timer.h>
2

3
struct timer_list my_timer;
4

5
void timer_callback(struct timer_list *t) {
6
    printk("Timer fired!\n");
7
    mod_timer(&my_timer, jiffies + HZ);  // 再次触发(1秒后)
8
}
9

10
// 初始化
11
timer_setup(&my_timer, timer_callback, 0);
12
mod_timer(&my_timer, jiffies + HZ);  // 1秒后触发
13

14
// 删除
15
del_timer_sync(&my_timer);

1
// 中断中短延迟
2
udelay(10);  // 10微秒(忙等)
3

4
// 进程上下文中延迟
5
msleep(100);  // 100毫秒(睡眠,不浪费CPU)
6
usleep_range(1000, 1500);  // 1~1.5ms(精度更好)

1
#include <linux/completion.h>
2

3
DECLARE_COMPLETION(my_comp);
4

5
// 等待方
6
wait_for_completion(&my_comp);  // 阻塞直到complete
7
// 或带超时
8
wait_for_completion_timeout(&my_comp, msecs_to_jiffies(1000));
9

10
// 完成方(如中断处理/另一线程)
11
complete(&my_comp);       // 唤醒一个等待者
12
complete_all(&my_comp);   // 唤醒所有等待者

1
#include <linux/atomic.h>
2

3
atomic_t counter = ATOMIC_INIT(0);
4

5
atomic_inc(&counter);              // counter++
6
atomic_dec(&counter);              // counter--
7
atomic_add(5, &counter);          // counter += 5
8
int val = atomic_read(&counter);  // 读取
9
atomic_set(&counter, 10);         // 设置
10

11
// 带返回值
12
int old = atomic_inc_return(&counter);  // ++counter并返回新值
13
if (atomic_dec_and_test(&counter))      // --counter==0?
14
    printk("Counter reached zero\n");

1
// printk级别
2
printk(KERN_EMERG   "Emergency\n");   // 0 系统崩溃
3
printk(KERN_ERR     "Error\n");       // 3 错误
4
printk(KERN_WARNING "Warning\n");     // 4 警告
5
printk(KERN_INFO    "Info\n");        // 6 信息
6
printk(KERN_DEBUG   "Debug\n");       // 7 调试
7

8
// 推荐使用dev_xxx(带设备信息)
9
dev_err(&pdev->dev, "Init failed: %d\n", ret);
10
dev_info(&pdev->dev, "Driver loaded\n");
11

12
// 动态调试
13
echo "module mymod +p" > /sys/kernel/debug/dynamic_debug/control

1
/* 字符设备驱动的框架？ - 示例实现 */
2
#include <linux/cdev.h>
3
#include <linux/fs.h>
4

5
static int my_open(struct inode *inode, struct file *filp) { return 0; }
6
static int my_release(struct inode *inode, struct file *filp) { return 0; }
7
static ssize_t my_read(struct file *filp, char __user *buf,
8
                       size_t count, loff_t *pos) {
9
    char kbuf[] = "hello";
10
    if (copy_to_user(buf, kbuf, sizeof(kbuf)))
11
        return -EFAULT;
12
    return sizeof(kbuf);
13
}
14
static ssize_t my_write(struct file *filp, const char __user *buf,
15
                        size_t count, loff_t *pos) {
15 collapsed lines
16
    char kbuf[64];
17
    if (count > sizeof(kbuf)) return -ENOMEM;
18
    if (copy_from_user(kbuf, buf, count))
19
        return -EFAULT;
20
    printk("Got: %.*s\n", (int)count, kbuf);
21
    return count;
22
}
23

24
static struct file_operations my_fops = {
25
    .owner = THIS_MODULE,
26
    .open = my_open,
27
    .release = my_release,
28
    .read = my_read,
29
    .write = my_write,
30
};

1
dev_t devno;
2

3
// 动态分配(推荐)
4
alloc_chrdev_region(&devno, 0, 1, "mydev");
5
int major = MAJOR(devno);
6
int minor = MINOR(devno);
7

8
// 静态分配(指定主设备号)
9
devno = MKDEV(240, 0);
10
register_chrdev_region(devno, 1, "mydev");
11

12
// 释放
13
unregister_chrdev_region(devno, 1);

1
static struct cdev my_cdev;
2
static struct class *my_class;
3
static dev_t devno;
4

5
static int __init my_init(void) {
6
    alloc_chrdev_region(&devno, 0, 1, "mydev");
7

8
    cdev_init(&my_cdev, &my_fops);
9
    cdev_add(&my_cdev, devno, 1);
10

11
    // 自动创建/dev/mydev(udev/mdev)
12
    my_class = class_create(THIS_MODULE, "myclass");
13
    device_create(my_class, NULL, devno, NULL, "mydev");
14

15
    return 0;
8 collapsed lines
16
}
17

18
static void __exit my_exit(void) {
19
    device_destroy(my_class, devno);
20
    class_destroy(my_class);
21
    cdev_del(&my_cdev);
22
    unregister_chrdev_region(devno, 1);
23
}

1
// 必须用copy_to/from_user的原因:
2
// 1. 地址合法性检查(access_ok)
3
// 2. 用户态地址可能未映射(触发缺页中断)
4
// 3. 如果直接memcpy → 内核oops崩溃
5

6
ssize_t my_read(struct file *filp, char __user *buf, size_t count, loff_t *pos) {
7
    char kernel_buf[64] = "data from kernel";
8
    int len = strlen(kernel_buf) + 1;
9

10
    if (count < len) len = count;
11
    if (copy_to_user(buf, kernel_buf, len))
12
        return -EFAULT;  // 地址无效
13
    return len;
14
}

1
// 定义ioctl命令码
2
#define MY_IOC_MAGIC 'k'
3
#define MY_IOC_GET_STATUS _IOR(MY_IOC_MAGIC, 1, int)
4
#define MY_IOC_SET_CONFIG _IOW(MY_IOC_MAGIC, 2, struct my_config)
5
#define MY_IOC_RESET     _IO(MY_IOC_MAGIC, 3)
6

7
static long my_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) {  // 设备控制操作
8
    switch (cmd) {
9
    case MY_IOC_GET_STATUS: {
10
        int status = get_hw_status();
11
        if (copy_to_user((void __user *)arg, &status, sizeof(status)))
12
            return -EFAULT;
13
        return 0;
14
    }
15
    case MY_IOC_SET_CONFIG: {
12 collapsed lines
16
        struct my_config cfg;
17
        if (copy_from_user(&cfg, (void __user *)arg, sizeof(cfg)))
18
            return -EFAULT;
19
        apply_config(&cfg);
20
        return 0;
21
    }
22
    case MY_IOC_RESET:
23
        hw_reset();
24
        return 0;
25
    }
26
    return -ENOTTY;
27
}

1
#include <linux/poll.h>
2
#include <linux/wait.h>
3

4
static wait_queue_head_t my_wq;
5
static int data_ready = 0;
6

7
static __poll_t my_poll(struct file *filp, poll_table *wait) {
8
    __poll_t mask = 0;
9
    poll_wait(filp, &my_wq, wait);
10
    if (data_ready)
11
        mask |= EPOLLIN | EPOLLRDNORM;
12
    return mask;
13
}
14

15
static ssize_t my_read(struct file *filp, char __user *buf,
13 collapsed lines
16
                       size_t count, loff_t *pos) {
17
    // 阻塞等待数据
18
    wait_event_interruptible(my_wq, data_ready != 0);
19
    // 返回数据...
20
    data_ready = 0;
21
    return count;
22
}
23

24
// 在中断或数据到达时唤醒
25
void data_arrived(void) {
26
    data_ready = 1;
27
    wake_up_interruptible(&my_wq);
28
}

1
static struct fasync_struct *my_fasync;
2

3
static int my_fasync_func(int fd, struct file *filp, int on) {
4
    return fasync_helper(fd, filp, on, &my_fasync);
5
}
6

7
// 数据到达时通知
8
void notify_app(void) {
9
    if (my_fasync)
10
        kill_fasync(&my_fasync, SIGIO, POLL_IN);
11
}
12

13
static struct file_operations fops = {
14
    .fasync = my_fasync_func,
15
    // ...
1 collapsed line
16
};

1
#include <linux/proc_fs.h>
2
#include <linux/seq_file.h>
3

4
static int my_proc_show(struct seq_file *m, void *v) {
5
    seq_printf(m, "status: %d\n", device_status);
6
    seq_printf(m, "count: %d\n", access_count);
7
    return 0;
8
}
9

10
static int my_proc_open(struct inode *inode, struct file *file) {
11
    return single_open(file, my_proc_show, NULL);
12
}
13

14
static const struct proc_ops my_proc_ops = {
15
    .proc_open = my_proc_open,
7 collapsed lines
16
    .proc_read = seq_read,
17
    .proc_lseek = seq_lseek,
18
    .proc_release = single_release,
19
};
20

21
// 创建/proc/mydriver
22
proc_create("mydriver", 0444, NULL, &my_proc_ops);

1
static ssize_t status_show(struct device *dev, struct device_attribute *attr,
2
                           char *buf) {
3
    return sprintf(buf, "%d\n", get_status());
4
}
5

6
static ssize_t config_store(struct device *dev, struct device_attribute *attr,
7
                            const char *buf, size_t count) {
8
    int val;
9
    if (kstrtoint(buf, 10, &val))
10
        return -EINVAL;
11
    set_config(val);
12
    return count;
13
}
14

15
static DEVICE_ATTR_RO(status);  // 只读
8 collapsed lines
16
static DEVICE_ATTR_RW(config);  // 读写
17

18
static struct attribute *my_attrs[] = {
19
    &dev_attr_status.attr,
20
    &dev_attr_config.attr,
21
    NULL,
22
};
23
ATTRIBUTE_GROUPS(my);

1
static ssize_t my_read(struct file *filp, char __user *buf,
2
                       size_t count, loff_t *pos) {
3
    if (!data_available()) {
4
        if (filp->f_flags & O_NONBLOCK)
5
            return -EAGAIN;  // 非阻塞:立即返回
6
        // 阻塞:等待数据
7
        if (wait_event_interruptible(my_wq, data_available()))
8
            return -ERESTARTSYS;  // 被信号中断
9
    }
10
    // 数据就绪,返回数据
11
    return copy_data_to_user(buf, count);
12
}

1
static int my_mmap(struct file *filp, struct vm_area_struct *vma) {
2
    unsigned long size = vma->vm_end - vma->vm_start;
3
    unsigned long pfn = virt_to_phys(my_buffer) >> PAGE_SHIFT;
4

5
    // 设置不可缓存(硬件寄存器)
6
    vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
7

8
    if (remap_pfn_range(vma, vma->vm_start, pfn, size, vma->vm_page_prot))
9
        return -EAGAIN;
10
    return 0;
11
}

1
#include <linux/miscdevice.h>
2

3
static struct file_operations my_fops = {
4
    .owner = THIS_MODULE,
5
    .read = my_read,
6
    .write = my_write,
7
    .unlocked_ioctl = my_ioctl,
8
};
9

10
static struct miscdevice my_misc = {
11
    .minor = MISC_DYNAMIC_MINOR,
12
    .name = "mymisc",
13
    .fops = &my_fops,
14
};
15

3 collapsed lines
16
// 注册:一步到位(自动创建/dev/mymisc)
17
misc_register(&my_misc);
18
misc_deregister(&my_misc);

1
struct my_device {
2
    int id;
3
    struct cdev cdev;
4
    struct device *dev;
5
    void __iomem *regs;
6
    spinlock_t lock;
7
    // ... 设备私有数据
8
};
9

10
// open时通过inode找到设备实例
11
static int my_open(struct inode *inode, struct file *filp) {
12
    struct my_device *mydev = container_of(inode->i_cdev, struct my_device, cdev);
13
    filp->private_data = mydev;  // 存入file私有数据
14
    return 0;
15
}
6 collapsed lines
16

17
// read/write/ioctl通过filp->private_data获取设备
18
static ssize_t my_read(struct file *filp, ...) {
19
    struct my_device *mydev = filp->private_data;
20
    // 针对具体设备实例操作
21
}

1
设备(device)         总线(bus)         驱动(driver)
2
    │                   │                   │
3
    └──→ platform_bus_type ←─────────────┘
4
              │
5
         匹配规则:
6
         1. device_tree(compatible)
7
         2. ACPI
8
         3. id_table(名字匹配)
9
         4. name字段匹配
10

11
         匹配成功 → 调用driver的probe()

1
#include <linux/platform_device.h>
2
#include <linux/of.h>
3

4
static int my_probe(struct platform_device *pdev) {
5
    dev_info(&pdev->dev, "Device probed!\n");
6
    // 获取资源、初始化硬件...
7
    return 0;
8
}
9

10
static int my_remove(struct platform_device *pdev) {
11
    dev_info(&pdev->dev, "Device removed\n");
12
    return 0;
13
}
14

15
static const struct of_device_id my_of_match[] = {
14 collapsed lines
16
    { .compatible = "vendor,my-device" },
17
    {},
18
};
19
MODULE_DEVICE_TABLE(of, my_of_match);
20

21
static struct platform_driver my_driver = {
22
    .probe = my_probe,
23
    .remove = my_remove,
24
    .driver = {
25
        .name = "my-device",
26
        .of_match_table = my_of_match,
27
    },
28
};
29
module_platform_driver(my_driver);

1
/ {
2
    compatible = "vendor,board";
3

4
    my_device@40000000 {
5
        compatible = "vendor,my-device";  // 匹配驱动
6
        reg = <0x40000000 0x1000>;         // 寄存器基地址和大小
7
        interrupts = <0 32 4>;             // 中断号
8
        clocks = <&clk_uart>;             // 时钟引用
9
        clock-names = "uart_clk";
10
        gpios = <&gpio0 5 GPIO_ACTIVE_LOW>;
11
        status = "okay";                   // 启用
12
    };
13
};

1
static int my_probe(struct platform_device *pdev) {
2
    struct device *dev = &pdev->dev;
3
    struct device_node *np = dev->of_node;
4

5
    // 获取寄存器地址(从reg属性)
6
    struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
7
    void __iomem *base = devm_ioremap_resource(dev, res);
8

9
    // 获取中断号
10
    int irq = platform_get_irq(pdev, 0);
11

12
    // 读取自定义属性
13
    u32 freq;
14
    of_property_read_u32(np, "clock-frequency", &freq);
15

8 collapsed lines
16
    const char *name;
17
    of_property_read_string(np, "label", &name);
18

19
    // 获取GPIO
20
    int gpio = of_get_named_gpio(np, "reset-gpios", 0);
21

22
    return 0;
23
}

1
// 普通方式(需要手动在remove/出错路径释放)
2
void *buf = kmalloc(1024, GFP_KERNEL);
3
// ... 如果后续出错需要kfree(buf)
4

5
// devm方式(设备移除/probe失败自动释放)
6
void *buf = devm_kmalloc(dev, 1024, GFP_KERNEL);
7
// 不需要手动free!
8

9
// 常用devm_xxx:
10
devm_ioremap_resource()    // 映射IO寄存器
11
devm_request_irq()         // 注册中断
12
devm_clk_get()            // 获取时钟
13
devm_gpio_request()       // 申请GPIO
14
devm_regulator_get()      // 获取电源

1
#include <linux/regmap.h>
2

3
// I2C设备使用regmap
4
static const struct regmap_config my_regmap_config = {
5
    .reg_bits = 8,
6
    .val_bits = 8,
7
    .max_register = 0xFF,
8
};
9

10
struct regmap *map = devm_regmap_init_i2c(client, &my_regmap_config);
11

12
// 统一的读写API(无论底层是I2C/SPI/MMIO)
13
regmap_read(map, REG_STATUS, &val);
14
regmap_write(map, REG_CTRL, 0x01);
15
regmap_update_bits(map, REG_CFG, MASK, VALUE);

1
// 设备树中声明pinctrl
2
my_device {
3
    pinctrl-names = "default", "sleep";
4
    pinctrl-0 = <&my_pins_default>;
5
    pinctrl-1 = <&my_pins_sleep>;
6
};
7

8
// 驱动中使用GPIO(新API: gpiod)
9
#include <linux/gpio/consumer.h>
10

11
struct gpio_desc *reset_gpio;
12
reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
13
gpiod_set_value(reset_gpio, 0);  // 拉低
14
msleep(10);
15
gpiod_set_value(reset_gpio, 1);  // 拉高

1
#include <linux/interrupt.h>
2

3
// 中断处理函数(顶半部: 快速，关中断)
4
static irqreturn_t my_isr(int irq, void *dev_id) {
5
    struct my_device *dev = dev_id;
6
    u32 status = readl(dev->regs + INT_STATUS);
7

8
    if (!(status & MY_INT_MASK))
9
        return IRQ_NONE;  // 不是我的中断
10

11
    // 清中断
12
    writel(status, dev->regs + INT_CLEAR);
13

14
    // 调度底半部(耗时工作)
15
    tasklet_schedule(&dev->tasklet);
7 collapsed lines
16
    // 或 schedule_work(&dev->work);
17

18
    return IRQ_HANDLED;
19
}
20

21
// 注册中断
22
devm_request_irq(dev, irq, my_isr, IRQF_SHARED, "mydev", mydev);

1
// request_threaded_irq: 硬中断仅做确认,线程中处理
2
static irqreturn_t my_hard_isr(int irq, void *dev_id) {
3
    // 快速确认中断(顶半部)
4
    return IRQ_WAKE_THREAD;  // 唤醒线程
5
}
6

7
static irqreturn_t my_thread_fn(int irq, void *dev_id) {
8
    // 线程上下文(可睡眠!)
9
    mutex_lock(&dev->lock);
10
    i2c_smbus_read_byte(dev->client);  // 可以做I2C操作
11
    mutex_unlock(&dev->lock);
12
    return IRQ_HANDLED;
13
}
14

15
devm_request_threaded_irq(dev, irq, my_hard_isr, my_thread_fn,
1 collapsed line
16
                          IRQF_ONESHOT, "mydev", mydev);

1
// 共享中断注册
2
request_irq(irq, my_isr, IRQF_SHARED, "mydev", my_private_data);
3

4
// ISR中必须判断是否是自己的中断
5
static irqreturn_t my_isr(int irq, void *dev_id) {
6
    struct my_device *dev = dev_id;
7
    if (!(readl(dev->regs + STATUS) & INT_PENDING))
8
        return IRQ_NONE;  // 不是我的,让下一个处理
9
    // 是我的中断,处理...
10
    return IRQ_HANDLED;
11
}

1
// 全局关中断(危险,尽量少用)
2
local_irq_disable();  // 关当前CPU中断
3
local_irq_enable();
4

5
// 保存/恢复中断状态(正确做法)
6
unsigned long flags;
7
local_irq_save(flags);   // 关中断+保存状态
8
// 临界区
9
local_irq_restore(flags); // 恢复原状态
10

11
// 关闭特定中断线
12
disable_irq(irq);     // 同步等待当前ISR执行完
13
disable_irq_nosync(irq); // 不等待
14
enable_irq(irq);