module_init(mod_init);   // insmod 时调用
module_exit(mod_exit);   // rmmod 时调用

major = register_chrdev(0, "simple_char", &fops);

copy_from_user(kernel_buffer, user_buffer, len);
copy_to_user(user_buffer, kernel_buffer, len);

# 查看内核构建配置中的关键设置
$ grep -rn "LLVM\|CLANG_VERSION\|NDK_TRIPLE" build.config.common build.config.constants
build.config.common:  LLVM=1
build.config.constants: CLANG_VERSION=r487747c
build.config.constants: AARCH64_NDK_TRIPLE=aarch64-linux-android31

source build/envsetup.sh
lunch ross-userdebug
# 进入内核目录自动有环境变量
cd common/common14-5.15/common
make menuconfig
make modules

make ARCH=arm64 LLVM=1 \
    CLANG_TRIPLE=aarch64-linux-android31- \
    CROSS_COMPILE=aarch64-linux-android31- \
    modules

export ALI_TOOLCHAIN=/path/to/arm-none-linux-gnueabihf

# 第 1 步：找到内核目录
ls ~/android/aml/s905x5/aml-s905x5-androidu-v2/common/
# 这个是内核源码目录（kernel 5.15）

# 第 2 步：把驱动源码放进去
cat > ~/android/aml/s905x5/aml-s905x5-androidu-v2/common/common14-5.15/common/drivers/misc/simple_char.c << 'EOF'
/*
 * simple_char — 最小字符设备驱动
 *
 * 功能：用户态写入的数据暂存在内核缓冲区，读取时返回该数据。
 *       相当于一个"内核版记事本"，用于演示 Linux 字符驱动骨架。
 *
 * 测试方式：
 *   echo "hello" > /dev/simple_char
 *   cat /dev/simple_char
 */

/* module.h：模块的 module_init/module_exit/MODULE_LICENSE 等宏定义 */
#include <linux/module.h>
/* kernel.h：printk 等内核打印函数 */
#include <linux/kernel.h>
/* fs.h：register_chrdev、unregister_chrdev、file_operations 结构体 */
#include <linux/fs.h>
/* uaccess.h：copy_to_user / copy_from_user —— 内核<->用户空间数据拷贝 */
#include <linux/uaccess.h>

/* 设备名称——注册时告诉内核，也用于 /proc/devices 显示和 mknod */
#define DEVICE_NAME "simple_char"

/* major：内核分配的主设备号，mknod 时用来建立设备节点 */
static int major;
/*
 * kernel_buffer：内核侧的存储缓冲区。
 * 用户 write 的数据暂存于此，read 时从此读出。
 * 简单驱动用固定大小；真实驱动需考虑并发、缓冲区溢出等问题。
 */
static char kernel_buffer[256] = {0};

/*
 * dev_open — open() 系统调用的内核侧实现
 *
 * inodep：文件在 VFS 层对应的 inode，用来获取设备信息
 * filep：文件打开后在内核中的表示，每个进程的每次 open 对应一个实例
 *
 * 返回 0 表示成功。大部分简单驱动只需要记录日志即可。
 */
static int dev_open(struct inode *inodep, struct file *filep) {
    printk(KERN_INFO "simple_char: open()\n");
    return 0;
}

/*
 * dev_read — read() 系统调用的内核侧实现
 *
 * buffer：用户态传入的缓冲区指针（带 __user 标记，不可直接解引用）
 * len：用户态请求读取的字节数
 * offset：文件读写偏移位置，记录已读到的位置。读操作从这里继续，读完一段后向后移动
 *
 * copy_to_user：将内核数据拷贝到用户空间
 *   - 返回值 0 表示全部拷贝成功
 *   - 返回值非零 = 未能拷贝的字节数
 *
 * 返回规则：
 *   0  = EOF，表示已读到末尾，调用者（如 cat）收到 0 后会停止读循环并退出
 *   >0 = 本次实际读取的字节数
 *   <0 = 错误码
 */
static ssize_t dev_read(struct file *filep, char __user *buffer,
                        size_t len, loff_t *offset) {
    int data_len = strlen(kernel_buffer);

    /* 已读到数据末尾，返回 EOF */
    if (*offset >= data_len)
        return 0;

    /* 限制读取长度不超过剩余数据 */
    if (len > data_len - *offset)
        len = data_len - *offset;

    if (copy_to_user(buffer, kernel_buffer + *offset, len))
        return -EFAULT;

    *offset += len;
    printk(KERN_INFO "simple_char: read() %zu bytes, offset=%lld\n", len, *offset);
    return len;
}

/*
 * dev_write — write() 系统调用的内核侧实现
 *
 * buffer：用户态传入的数据指针（带 __user，需用 copy_from_user 访问）
 * len：用户态请求写入的字节数
 *
 * copy_from_user：将用户空间数据拷贝到内核缓冲区
 *   - 检查用户指针合法性，处理缺页
 *   - 返回值 = 未能拷贝成功的字节数（0 = 全部成功）
 */
static ssize_t dev_write(struct file *filep, const char __user *buffer,
                         size_t len, loff_t *offset) {
    int ret = copy_from_user(kernel_buffer, buffer, len);
    printk(KERN_INFO "simple_char: write() %zu bytes\n", len);
    return ret ? -EFAULT : len;
}

/*
 * file_operations 结构体：
 * 字符驱动的核心——将用户态系统调用（open/read/write/ioctl/release...）
 * 映射到驱动中的具体实现函数。这是 Linux 驱动多态机制的体现。
 *
 * 未被赋值的成员（如 release/ioctl）内核会使用默认行为。
 */
static struct file_operations fops = {
    .open = dev_open,
    .read = dev_read,
    .write = dev_write,
};

/*
 * mod_init — 模块入口（insmod 时执行）
 * __init 标记：此函数运行结束后内核可回收其内存
 *
 * register_chrdev(0, DEVICE_NAME, &fops)：
 *   - 参数 0 表示让内核自动分配主设备号
 *   - 返回的 major 保存分配到的设备号
 */
static int __init mod_init(void) {
    major = register_chrdev(0, DEVICE_NAME, &fops);
    printk(KERN_INFO "simple_char: loaded, major=%d\n", major);
    return 0;
}

/*
 * mod_exit — 模块出口（rmmod 时执行）
 * __exit 标记：模块内建时不编译此函数以节省内存
 *
 * unregister_chrdev：注销设备，释放主设备号
 * 必须在 exit 中注销，否则模块卸载后 /dev/simple_char 成为空悬节点。
 */
static void __exit mod_exit(void) {
    unregister_chrdev(major, DEVICE_NAME);
    printk(KERN_INFO "simple_char: unloaded\n");
}

/* 注册模块的初始化和退出函数 */
module_init(mod_init);
module_exit(mod_exit);

/* GPL 声明：使用 GPL 协议，不声明则内核拒绝加载或标记为污染 */
MODULE_LICENSE("GPL");
EOF

# 第 3 步：修改 Kconfig（让它在 menuconfig 中可见）
# 编辑 common/drivers/misc/Kconfig，在合适位置加入：
# tristate代表了三态 y/n/m  m表示模块，选择y那么simple_char.c 被编译进内核，选择m的话就会生成simple_char.ko
 config SIMPLE_CHAR
    tristate "Simple character device driver"
    help
      A minimal character device driver for learning.

# 第 4 步：修改 Makefile 加入编译
# 编辑 common/drivers/misc/Makefile，加入：
# 这里的CONFIG_SIMPLE_CHAR依赖于第3步中配置的SIMPLE_CHAR，系统会自动变成CONFIG_SIMPLE_CHAR
obj-$(CONFIG_SIMPLE_CHAR) += simple_char.o

# 第 5 步：注册到 Bazel 模块输出列表
# 编辑 common/common14-5.15/common/common_drivers/modules.bzl
# 在 AMLOGIC_COMMON_MODULES 列表中（按字母序）加入：
#     "drivers/misc/simple_char.ko",
# 否则 Bazel 虽然编译了模块但不会复制到 dist 输出目录
#  modules.bzl (AMLOGIC_COMMON_MODULES 列表)
#      → Bazel 编译生成 simple_char.ko
#      → depmod 生成 modules.dep（模块依赖关系）
#      → amlogic_utils.sh 把 modules.dep 转成 modules.load（去掉依赖信息，只留模块名）
#      → 放入 out/target/product/ross/vendor_dlkm/lib/modules/modules.load


# 第 6 步：编译内核模块
cd ~/android/aml/s905x5/aml-s905x5-androidu-v2/
cd common/common14-5.15/common
make menuconfig #在
# 在 Device Drivers → Misc devices 中找到 Simple character device driver，设为 M（模块）
make modules

# 第 7 步：测试连接
# 接上板子的 adb 连接
adb devices
# 预期输出：列出已连接的设备，状态为 "device"

# 确认模块已加载（烧录后自动加载，无需 insmod）
adb shell ls /vendor/lib/modules/simple_char.ko
# 预期输出：/vendor/lib/modules/simple_char.ko（文件存在）

adb shell cat /proc/devices | grep simple_char
# 预期输出：类似 "252 simple_char"
# 说明：主设备号（252 是示例，每次可能不同）是内核分配的，mknod 时需用这个数字

# 创建设备节点（让用户态能通过 /dev/simple_char 访问驱动）
adb shell mknod /dev/simple_char c <上一步中的major> 0
adb shell chmod 666 /dev/simple_char
# 说明：mknod 参数 c=字符设备，<major>=主设备号，0=次设备号
#       chmod 666 让所有用户可读写，避免权限拒绝

adb shell ls -l /dev/simple_char
# 预期输出：类似 "crw-rw-rw- 1 root root 252, 0 ... /dev/simple_char"
# 说明：开头的 c 表示字符设备，252,0 是主次设备号

# 第 8 步：验证驱动读写
# 写入数据：用 echo 重定向到设备节点，触发驱动的 dev_write()
adb shell "echo 'hello from userspace' > /dev/simple_char"

# 读出数据：用 cat 读取设备节点，触发驱动的 dev_read()
adb shell cat /dev/simple_char
# 预期输出：hello from userspace
# 说明：读出内容应与写入的一致，证明数据经过内核缓冲区转储正确

# 查看内核日志，确认驱动各函数被成功调用
adb shell dmesg | grep simple_char
# 预期输出：
#   simple_char: loaded, major=252          ← mod_init()，模块加载
#   simple_char: open()                      ← dev_open()，echo 触发 open
#   simple_char: write() 21 bytes            ← dev_write()，写入的数据长度
#   simple_char: open()                      ← dev_open()，cat 触发 open
#   simple_char: read() 21 bytes             ← dev_read()，读取的数据长度

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>

int main(void) {
    char wbuf[] = "hello driver";
    char rbuf[64] = {0};
    int fd;

    /* open: 用户态 open → VFS → 驱动 dev_open */
    fd = open("/dev/simple_char", O_RDWR);
    if (fd < 0) {
        perror("open");
        return 1;
    }
    printf("open() fd=%d\n", fd);

    /* write: 用户态 write → VFS → 驱动 dev_write */
    write(fd, wbuf, strlen(wbuf));
    printf("write() %zu bytes\n", strlen(wbuf));

    /* read: 用户态 read → VFS → 驱动 dev_read */
    read(fd, rbuf, sizeof(rbuf));
    printf("read() got: %s\n", rbuf);

    /* close: 用户态 close → VFS → 驱动 dev_release（本例未实现，内核默认处理） */
    close(fd);
    printf("close()\n");

    return 0;
}

# PC 端交叉编译（使用 musl 静态链接，无需依赖目标板的 libc）
CLANG=~/android/aml/s905x5/aml-s905x5-androidu-v2/prebuilts/clang/host/linux-x86/clang-r487747c/bin/clang
SYSROOT=~/android/aml/s905x5/aml-s905x5-androidu-v2/prebuilts/build-tools/sysroots/aarch64-unknown-linux-musl

$CLANG --target=aarch64-unknown-linux-musl \
    --sysroot=$SYSROOT \
    -static \
    -rtlib=compiler-rt \
    -unwindlib=libunwind \
    -o test_simple_char test_simple_char.c

# 验证二进制
file test_simple_char
# 预期输出：ELF 64-bit LSB executable, ARM aarch64, statically linked ...

# 推送到板子运行
adb push test_simple_char /data/local/tmp/
adb shell /data/local/tmp/test_simple_char

# 预期输出：
# open() fd=3
# write() 13 bytes
# read() got: hello driver
# close()