从零搭建虚拟NPU：手把手实现AI芯片驱动与矩阵乘法

AI芯片这个关键词最近热度很高，不少讨论集中在公司估值、流片进度和算力数字上，但如果把视角切到开发者一侧，真正决定芯片能不能落地的其实是软件栈，尤其是“AI芯片驱动开发”这条链路。一颗 AI 加速芯片从裸片到能被上层框架调用，中间隔着指令集、内核驱动、用户态运行时、算子库和编译器。本文不讨论某家公司或某款芯片的具体参数，而是从工程可复现的角度，演示在没有真实硬件时，如何通过模拟器、内核模块和用户态 runtime，把一个虚拟 NPU 从零搭起来，并跑通一次矩阵乘法。

读者可以在阅读后得到两样东西：一是对 AI 芯片软件栈的整体认知，知道驱动程序在芯片体系中处于哪个位置；二是可以直接编译运行的最小实验环境，包含内核驱动、用户态封装库和验证程序。这套实验不依赖昂贵开发板，只需要一台普通 Linux 主机和内核头文件，重点是理解“应用程序 -> 运行时 -> 内核驱动 -> 硬件模拟器”这条完整链路。

1. 先理解 AI 芯片开发为什么绕不开驱动和工具链

1.1 新闻里的 AI 芯片与开发者眼中的 AI 芯片是两回事

估值 223 亿元的创业故事让人首先想到硬件、流片、制程、算力，但实际开发者在接触一颗 AI 芯片时，拿到手的往往不是电路图，而是一套 SDK。这套 SDK 里最底层的就是驱动程序，驱动负责把上层的计算请求翻译成芯片能理解的寄存器写入、内存搬运和指令触发。没有驱动，芯片就像一块无法访问的设备，编译器生成的指令也无法执行。

一颗 AI 芯片的软件栈通常分成五层：

常见误区是把“驱动开发”理解为写一个能 open、read、write 的字符设备。实际 AI 芯片驱动比普通设备驱动复杂得多，它需要处理命令队列、内存 pin 住、多级中断、多进程并发、电源管理和固件加载。不过这些复杂机制的基础仍然是最经典的设备模型、file_operations、mmap 和 ioctl。本文从这个基础开始，搭建一个可扩展的骨架，后续再逐步增加 DMA、中断等机制。

1.2 没有实体芯片时，如何把驱动开发学起来

很多开发者想学 AI 芯片驱动，但手边没有开发板，也不想承担硬件成本。替代方案是用模拟器。模拟器不需要真实电路，只要能响应寄存器读写、模拟计算行为、返回结果即可。

学习路径可以这样设计：

1. 在内核模块中注册一个虚拟字符设备，模拟 NPU 的设备节点。
2. 通过 ioctl 模拟指令下发，通过 read/write 模拟数据搬运。
3. 在用户态写一个计算模拟器，用 CPU 代码模拟矩阵乘，扮演“硬件计算单元”。
4. 用封装好的 runtime 库统一接口，让上层代码不感知硬件是真实芯片还是模拟器。

这样做的优点是：不需要采购硬件，代码逻辑和真实驱动相似，而且每一步都可以通过日志和返回值验证。缺点也同样明显：模拟器不涉及真实寄存器的时序、DMA 延迟、中断竞争，所以文章和代码中会明确标注“学习环境”与“生产环境”的差异。把这套实验跑通之后，再转向真实开发板，成本和阻力会小很多。

2. 搭建学习环境：用虚拟 NPU 模拟器跑通最小软件栈

2.1 环境要求与检查命令

实验环境建议使用 Linux 内核 5.4 或更高版本。需要保证内核头文件已经安装，编译器可以工作。以下命令用于快速检查：

uname -r gcc --version make --version ls /lib/modules/$(uname -r)/build

如果/lib/modules/$(uname -r)/build目录不存在，需要安装内核开发包。不同发行版命令不同：

检查设备的编译环境是否完整，可以尝试编译一个最小 Hello World 模块。不过本文后面会直接给出完整模块，编译时如果报错，优先检查内核头文件版本是否与当前内核一致。

2.2 项目目录结构

在一个普通用户目录下创建实验项目，目录结构如下：

virtual-npu/ ├── Makefile ├── vnpu.c ├── libnpu.c ├── libnpu.h ├── test_npu.c └── README.md

• vnpu.c是内核驱动模块，注册虚拟 NPU 设备，提供 open、read、write、ioctl 接口。
• libnpu.c和libnpu.h是用户态运行时封装，隐藏设备访问细节，提供矩阵乘法 API。
• test_npu.c是验证程序，调用npu_matmul完成一次矩阵乘法并检查结果。
• Makefile负责编译内核模块和用户态程序。

2.3 为什么选择字符设备而不是真实 PCIe 设备

真实 AI 加速卡通常挂在 PCIe 总线上，驱动需要注册 PCI 驱动、处理 BAR 空间、配置 DMA 和 MSI 中断。学习阶段如果直接写 PCIe 驱动，调试门槛太高。字符设备配合 miscdevice 框架是最简单的 Linux 设备驱动模型，可以快速创建一个/dev/vnpu0节点，让上层业务先跑起来。

两种路径的对比：

学习阶段先选低成本的方案，重点是打通软件链路。生产环境要按真实总线模型重写设备绑定逻辑，这一区别在最终章节会展开说明。

3. 最小实现：一个可读可写的虚拟 NPU 驱动

3.1 驱动设计思路

驱动内部维护一个vnpu_device结构体，包含数据缓冲区、状态字段和统计信息。上层通过 ioctl 下发控制命令，通过 read/write 写入输入数据和读取输出结果。为了模拟真实芯片的“计算耗时”，ioctl 的启动命令会让驱动短暂休眠一段时间，再更新状态。这是教学模拟，不代表真实芯片的延迟模型。

核心接口定义如下：

#define NPU_IOCTL_MAGIC 'N' #define NPU_IOCTL_RESET _IO(NPU_IOCTL_MAGIC, 0) #define NPU_IOCTL_START _IO(NPU_IOCTL_MAGIC, 1) #define NPU_IOCTL_STATUS _IOR(NPU_IOCTL_MAGIC, 2, int) #define NPU_IOCTL_STATS _IOR(NPU_IOCTL_MAGIC, 3, struct vnpu_stats)

NPU_IOCTL_START表示启动一次计算。NPU_IOCTL_STATUS查询设备状态。NPU_IOCTL_STATS返回设备累计计算次数。

3.2 内核模块核心代码

下面是vnpu.c的完整可编译版本，已在 5.10 内核验证思路，实际编译时请根据内核版本微调。

#include <linux/module.h> #include <linux/kernel.h> #include <linux/fs.h> #include <linux/miscdevice.h> #include <linux/uaccess.h> #include <linux/slab.h> #include <linux/delay.h> #include <linux/mutex.h> #define VNPU_DEV_NAME "vnpu0" #define VNPU_BUF_SIZE 4096 #define NPU_IOCTL_MAGIC 'N' #define NPU_IOCTL_RESET _IO(NPU_IOCTL_MAGIC, 0) #define NPU_IOCTL_START _IO(NPU_IOCTL_MAGIC, 1) #define NPU_IOCTL_STATUS _IOR(NPU_IOCTL_MAGIC, 2, int) #define NPU_IOCTL_STATS _IOR(NPU_IOCTL_MAGIC, 3, struct vnpu_stats) struct vnpu_stats { unsigned long total_commands; unsigned long total_bytes; }; struct vnpu_device { char *buf; size_t buf_size; int status; struct mutex lock; struct vnpu_stats stats; }; static struct vnpu_device vnpu_dev; static int vnpu_open(struct inode *inode, struct file *file) { return 0; } static ssize_t vnpu_read(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { ssize_t ret; if (count > vnpu_dev.buf_size - *ppos) count = vnpu_dev.buf_size - *ppos; mutex_lock(&vnpu_dev.lock); ret = simple_read_from_buffer(user_buf, count, ppos, vnpu_dev.buf, vnpu_dev.buf_size); mutex_unlock(&vnpu_dev.lock); return ret; } static ssize_t vnpu_write(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { ssize_t ret; if (count > vnpu_dev.buf_size - *ppos) count = vnpu_dev.buf_size - *ppos; mutex_lock(&vnpu_dev.lock); ret = simple_write_to_buffer(vnpu_dev.buf, vnpu_dev.buf_size, ppos, user_buf, count); vnpu_dev.stats.total_bytes += ret; mutex_unlock(&vnpu_dev.lock); return ret; } static long vnpu_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { long ret = 0; mutex_lock(&vnpu_dev.lock); switch (cmd) { case NPU_IOCTL_RESET: vnpu_dev.status = 0; vnpu_dev.stats.total_commands = 0; break; case NPU_IOCTL_START: vnpu_dev.status = 1; vnpu_dev.stats.total_commands++; mutex_unlock(&vnpu_dev.lock); msleep(10); mutex_lock(&vnpu_dev.lock); vnpu_dev.status = 2; break; case NPU_IOCTL_STATUS: if (copy_to_user((int __user *)arg, &vnpu_dev.status, sizeof(int))) { ret = -EFAULT; } break; case NPU_IOCTL_STATS: if (copy_to_user((struct vnpu_stats __user *)arg, &vnpu_dev.stats, sizeof(struct vnpu_stats))) { ret = -EFAULT; } break; default: ret = -ENOTTY; break; } mutex_unlock(&vnpu_dev.lock); return ret; } static const struct file_operations vnpu_fops = { .owner = THIS_MODULE, .open = vnpu_open, .read = vnpu_read, .write = vnpu_write, .unlocked_ioctl = vnpu_ioctl, }; static struct miscdevice vnpu_misc = { .minor = MISC_DYNAMIC_MINOR, .name = VNPU_DEV_NAME, .fops = &vnpu_fops, }; static int __init vnpu_init(void) { int ret; memset(&vnpu_dev, 0, sizeof(vnpu_dev)); vnpu_dev.buf = kzalloc(VNPU_BUF_SIZE, GFP_KERNEL); if (!vnpu_dev.buf) return -ENOMEM; vnpu_dev.buf_size = VNPU_BUF_SIZE; mutex_init(&vnpu_dev.lock); ret = misc_register(&vnpu_misc); if (ret) { kfree(vnpu_dev.buf); pr_err("vnpu: misc_register failed, ret=%d\n", ret); return ret; } pr_info("vnpu: virtual NPU device registered\n"); return 0; } static void __exit vnpu_exit(void) { misc_deregister(&vnpu_misc); kfree(vnpu_dev.buf); mutex_destroy(&vnpu_dev.lock); pr_info("vnpu: device unregistered\n"); } module_init(vnpu_init); module_exit(vnpu_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Virtual NPU Lab"); MODULE_DESCRIPTION("Virtual NPU driver for learning AI chip software stack");

关键点如下：

• misc_register会自动在/dev下创建设备节点，省去手动mknod。
• simple_read_from_buffer和simple_write_to_buffer负责用户态与内核态之间的缓冲区拷贝，避免重复实现边界检查。
• NPU_IOCTL_START中先解锁再msleep，模拟设备执行耗时。这里刻意避免在持锁状态下休眠，否则其他进程访问设备时会被长时间阻塞。
• copy_to_user的返回值必须检查，失败时返回-EFAULT，避免用户态拿到错误状态。
• -ENOTTY是 ioctl 不支持该命令时常用的错误码，用户态调用失败时可以通过perror看到 “Inappropriate ioctl for device”。

3.3 Makefile 与编译加载

Makefile 同时编译内核模块和用户态程序：

obj-m := vnpu.o KERNEL_DIR ?= /lib/modules/$(shell uname -r)/build all: make -C $(KERNEL_DIR) M=$(PWD) modules gcc -Wall -o test_npu test_npu.c libnpu.c clean: make -C $(KERNEL_DIR) M=$(PWD) clean rm -f test_npu

编译并加载模块：

make sudo insmod vnpu.ko lsmod | grep vnpu ls -l /dev/vnpu0

预期输出类似：

crw------- 1 root root 10, 123 May 1 10:00 /dev/vnpu0

设备节点存在后，用dmesg | tail查看内核打印：

[12345.678901] vnpu: virtual NPU device registered

如果misc_register失败，通常是模块重复加载或者设备编号冲突。可以先查看内核日志，再决定是否需要rmmod vnpu后重新加载。

4. 把矩阵乘法送入芯片：从算法到指令到运行时

4.1 为什么矩阵乘法是 AI 芯片的核心计算

神经网络中的卷积、全连接、注意力机制，最终都会映射为大量矩阵乘法。AI 芯片在设计时往往围绕矩阵乘单元做架构优化。对驱动开发者来说，理解矩阵乘的映射方式很重要，因为指令设计、内存布局和数据搬运方式都围绕它展开。

学习阶段可以把矩阵乘法拆成三个动作：

1. 把输入矩阵 A 和 B 写入设备缓冲区。
2. 启动计算指令，模拟芯片执行。
3. 从设备缓冲区读回结果矩阵 C。

4.2 用户态运行时封装

libnpu.h对外提供两个接口：

#ifndef LIBNPU_H #define LIBNPU_H #include <stddef.h> int npu_matmul(const float *A, const float *B, float *C, int M, int N, int K); #endif

libnpu.c负责打开设备、写入输入数据、下发启动命令、读取结果、关闭设备。为了模拟真实芯片行为，库内部用 CPU 代码完成矩阵乘计算，同时通过 ioctl 通知驱动记录统计信息。编码方式直接使用 IEEE 754 单精度浮点，满足学习验证即可。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <fcntl.h> #include <unistd.h> #include <sys/ioctl.h> #include "libnpu.h" #define DEVICE_PATH "/dev/vnpu0" #define NPU_IOCTL_MAGIC 'N' #define NPU_IOCTL_RESET _IO(NPU_IOCTL_MAGIC, 0) #define NPU_IOCTL_START _IO(NPU_IOCTL_MAGIC, 1) #define NPU_IOCTL_STATUS _IOR(NPU_IOCTL_MAGIC, 2, int) #define NPU_IOCTL_STATS _IOR(NPU_IOCTL_MAGIC, 3, struct vnpu_stats) struct vnpu_stats { unsigned long total_commands; unsigned long total_bytes; }; static void matrix_multiply_cpu(const float *A, const float *B, float *C, int M, int N, int K) { for (int i = 0; i < M; i++) { for (int j = 0; j < N; j++) { float sum = 0.0f; for (int p = 0; p < K; p++) { sum += A[i * K + p] * B[p * N + j]; } C[i * N + j] = sum; } } } int npu_matmul(const float *A, const float *B, float *C, int M, int N, int K) { int fd; int ret = 0; int status = 0; size_t bytes_a = (size_t)M * K * sizeof(float); size_t bytes_b = (size_t)K * N * sizeof(float); size_t bytes_c = (size_t)M * N * sizeof(float); float *inbuf = NULL; size_t total = bytes_a + bytes_b + bytes_c; if (total > 4096) { fprintf(stderr, "npu_matmul: buffer size exceeded, use smaller matrix\n"); return -1; } fd = open(DEVICE_PATH, O_RDWR); if (fd < 0) { perror("open /dev/vnpu0"); return -1; } inbuf = (float *)malloc(total); if (!inbuf) { close(fd); return -1; } memcpy(inbuf, A, bytes_a); memcpy(inbuf + (size_t)M * K, B, bytes_b); if (write(fd, inbuf, total) != (ssize_t)total) { perror("write input to vnpu"); ret = -1; goto out; } matrix_multiply_cpu(A, B, C, M, N, K); if (ioctl(fd, NPU_IOCTL_START) < 0) { perror("ioctl start"); ret = -1; goto out; } if (ioctl(fd, NPU_IOCTL_STATUS, &status) < 0) { perror("ioctl status"); ret = -1; goto out; } if (status != 2) { fprintf(stderr, "npu_matmul: unexpected device status %d\n", status); ret = -1; goto out; } if (read(fd, inbuf, total) != (ssize_t)total) { perror("read output from vnpu"); ret = -1; goto out; } memcpy(C, inbuf + (size_t)M * K + (size_t)K * N, bytes_c); out: free(inbuf); close(fd); return ret; }

这段代码的关键逻辑：

• 先写输入数据，再启动计算，最后读回结果，对应真实 AI 芯片的“搬运数据 -> 启动执行 -> 回读结果”流程。
• 缓冲区总大小限制为 4096 字节，和内核模块中定义的VNPU_BUF_SIZE保持一致。如果矩阵尺寸超过限制，库会直接报错。
• 计算结果由 CPU 模拟器生成，驱动本身并不计算。真实芯片中，计算单元是硬件模块，驱动只负责调度。
• ioctl(fd, NPU_IOCTL_START)会阻塞约 10 毫秒，模拟设备执行耗时。真实驱动通常使用异步队列，不会让应用层直接等待 10 毫秒，但阻塞模型更方便学习。

4.3 指令编码的入门概念

真实 AI 芯片驱动会使用指令描述符描述一次计算，指令描述符通常包含：

在虚拟实验中，这些信息通过 ioctl 参数传递，或者直接硬编码在库中。如果你想扩展实验，可以在 ioctl 中增加一个struct npu_command，把矩阵维度、算子和数据地址传下去，让驱动做更精细的调度。

5. 如何验证“芯片真的算了”：设备节点、内核日志和用户态测试

5.1 编写用户态测试程序

test_npu.c使用 4x4 矩阵，调用libnpu提供的接口，然后逐项比对结果。

#include <stdio.h> #include <math.h> #include "libnpu.h" #define M 4 #define N 4 #define K 4 static void print_matrix(const char *name, const float *mat, int rows, int cols) { printf("%s:\n", name); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { printf("%8.2f ", mat[i * cols + j]); } printf("\n"); } } static int compare_matrix(const float *got, const float *want, int rows, int cols) { int errors = 0; for (int i = 0; i < rows * cols; i++) { if (fabsf(got[i] - want[i]) > 1e-3f) { printf("mismatch at %d: got=%f want=%f\n", i, got[i], want[i]); errors++; } } return errors; } int main(void) { float A[M * K] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; float B[K * N] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 }; float C[M * N] = {0}; float expect[M * N] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; if (npu_matmul(A, B, C, M, N, K) != 0) { printf("npu_matmul failed\n"); return 1; } print_matrix("A", A, M, K); print_matrix("B", B, K, N); print_matrix("C", C, M, N); if (compare_matrix(C, expect, M, N) != 0) { printf("result check FAILED\n"); return 1; } printf("result check PASSED\n"); return 0; }

运行程序：

./test_npu

预期输出包括矩阵打印和最终判定：

A: 1.00 2.00 3.00 4.00 5.00 6.00 7.00 8.00 9.00 10.00 11.00 12.00 13.00 14.00 15.00 16.00 B: 1.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 1.00 0.00 0.00 0.00 0.00 1.00 C: 1.00 2.00 3.00 4.00 5.00 6.00 7.00 8.00 9.00 10.00 11.00 12.00 13.00 14.00 15.00 16.00 result check PASSED

这里选择单位矩阵作为 B，这样期望结果可以直接复用 A 的值，不需要手工算矩阵乘法，降低验证成本。

5.2 通过内核日志和统计信息确认设备状态

用户态程序只证明用户态链路通，还需要通过内核日志确认驱动确实被调用过。

dmesg | tail -n 20

如果驱动被正确加载，会看到注册信息。为了确认 ioctl 调用确实进入内核，可以在驱动中临时加入pr_info，但这需要重编模块。更轻量的做法是在用户态写一个小工具查询统计信息。

在test_npu.c或单独工具中可以加入：

struct vnpu_stats stats; int fd = open("/dev/vnpu0", O_RDWR); if (fd >= 0 && ioctl(fd, NPU_IOCTL_STATS, &stats) == 0) { printf("total_commands=%lu total_bytes=%lu\n", stats.total_commands, stats.total_bytes); } close(fd);

运行后应该看到total_commands至少为 1，total_bytes等于写入缓冲区的字节数。这一步能够把“驱动被调用”从“程序正常退出”中区分出来，避免用户态模拟器悄悄计算结果，而驱动根本没参与。

5.3 验证过程中常用的检查命令

如果设备节点不存在，但模块注册成功，可能是 udev 规则问题，也可以手动挂载 devtmpfs，但一般情况下不需要。

6. 驱动开发常见问题排查：按现象找根因

6.1 模块编译失败：缺少内核头文件或版本不匹配

现象：

make: *** /lib/modules/5.10.0-xxx/build: No such file or directory. Stop.

原因：

• 没有安装内核开发包。
• 内核头文件与当前运行内核版本不一致。
• Makefile 中KERNEL_DIR指向了错误路径。

排查顺序：

1. 运行uname -r确认当前内核版本。
2. 运行ls /lib/modules/$(uname -r)/build确认路径存在。
3. 检查/lib/modules/$(uname -r)/build/Makefile是否存在。
4. 如果路径不存在，按发行版安装对应kernel-devel。

6.2 加载模块报错：模块已存在或设备号冲突

现象：

insmod: ERROR: could not insert module vnpu.ko: File exists

原因：

• 上一次测试没有卸载模块。
• 有同名模块被系统加载。

解决：

sudo rmmod vnpu sudo insmod vnpu.ko dmesg | tail

如果rmmod提示模块被占用，说明还有进程持有设备节点，需要先关闭测试程序或找到对应进程。

6.3 用户态 ioctl 返回 Inappropriate ioctl for device

现象：

ioctl start: Inappropriate ioctl for device

原因：

• 用户态头文件和内核模块的头文件定义不一致。
• _IO宏生成号码不一致，常见于MAGIC重复或NR冲突。
• 设备节点指向了错误驱动。

排查方式：

1. 确认用户态程序和内核模块中的NPU_IOCTL_MAGIC一致。
2. 确认打开的设备路径是/dev/vnpu0。
3. 用cat /proc/misc查看次设备号。

真实项目中，内核模块和用户态库的 ioctl 定义常常存在重复，建议统一维护在一个公共头文件中，避免手写两套。

6.4 写入数据后读回结果不正确

现象：

• 测试程序退出正常。
• 对比矩阵时出现 mismatch。
• 输出矩阵全部为 0，或者数据错位。

可能原因：

• 写入缓冲区时矩阵拼接顺序错误。
• 读取结果时偏移不对。
• 用户态与内核态之间字节序不一致。

排查方式：

1. 先打印写出的缓冲区开头 16 字节，确认 A 和 B 的顺序。
2. 打印读回缓冲区，确认偏移位置。
3. 把内核缓冲区大小VNPU_BUF_SIZE调大一倍，排除缓冲区截断问题。

对于浮点数据，还需要注意精度问题。真实 AI 计算对精度要求高，学习环境使用float做对比时，要设置合理误差阈值，不要用==精确比较。

6.5 设备统计信息不增长

现象：

• 多次调用npu_matmul。
• 查询total_commands始终为 0。

可能原因：

• 测试程序没有真正打开/dev/vnpu0。
• 权限不足，open 返回-EACCES。
• 用户态库在打开设备前发生了提前退出。

排查方式：

1. 在测试程序里显式打印open返回值。
2. 用sudo ./test_npu尝试一次，排除权限问题。
3. 内核模块中在 ioctl 分支里增加pr_info输出，重新编译后查看 dmesg。

6.6 常用排错清单

7. 从虚拟设备到真实 AI 芯片：值得坚持的扩展方向

7.1 学习环境与生产环境的差异

上面的虚拟实验把许多复杂机制简化了，真实 AI 芯片驱动开发还需要额外关注：

建议在完成虚拟实验后，再进入真实开发板或 QEMU 的 PCIe 模拟环境，逐步增加 DMA 和中断。不要停留在“字符设备能跑矩阵乘”这个阶段。

7.2 建立可复用的驱动开发检查清单

在开始一个 AI 芯片驱动之前，建议先回答以下问题：

1. 硬件挂在哪条总线上？PCIe、AMBA、还是自定义总线？
2. 是否有 BAR 空间？寄存器偏移表在哪里？
3. 计算指令是内存映射还是消息队列？
4. 输入输出缓冲区如何分配？是否需要物理连续内存？
5. 一次计算是否耗时可估计？驱动用阻塞同步还是异步通知？
6. 多进程访问时，队列和上下文如何隔离？
7. 固件怎么加载？失败后的回退策略是什么？
8. 错误状态如何上报？是否有独立错误中断？
9. 用什么工具验证？用户态是否有可对拍的 CPU 实现？
10. 如何做性能测试？数据搬运时间占整个计算时间的比例是多少？

这些问题没有统一答案，不同芯片设计差异很大。但提前把清单列出来，能够有效避免“驱动写完了，设备却一直不工作”的窘境。

7.3 推荐的学习路径与实验深度

如果目标是进入真实 AI 芯片软件栈，可以按以下阶段安排学习：

1. 本文的虚拟 NPU 实验，理解字符设备、ioctl、用户态 runtime 的配合。
2. 深入学习 Linux 设备模型：platform_driver、device tree、资源获取。
3. 学习中断处理：tasklet、workqueue、threaded irq，理解下半部机制。
4. 学习 DMA 子系统：dma_alloc_coherent、dma_map_single、DMA 方向。
5. 学习 PCIe 驱动框架：pci_register_driver、resource 读取、MSI-X。
6. 结合编译器与运行时：了解从 ONNX 到指令的编译流程，理解驱动之上的一层。
7. 选择一款开源模拟器或真实开发板，完成一个真实算子。

每一步都尽量留一个可运行示例。内核驱动开发最容易出现的错误是“概念懂了，但代码无法编译”，因此所有学习阶段都要配套完整工程代码，不要只摘抄片段。本文的虚拟 NPU 实验就是一个很好的起点，后续可以把它扩展成多队列调度器、加入 DMA 模拟、增加中断请求，逐步逼近真实驱动的复杂度。