fixed-link.com

SD卡极限压测与驱动死机崩溃排查记录

2026-07-17T00:00:00+00:00

压测背景与测试程序设计

双线程异步架构：设计了生产线程专门负责产生数据，写入线程专门负责写盘，中间通过有界队列（最大长度限制为2）进行通信，强制生产端与写入端同步节奏，防止内存溢出 (OOM)。
极限防压缩机制：使用 xorshift32 快速伪随机算法填充内存，彻底废掉 SD 卡内部主控的压缩策略（FTL），使得每一笔数据都能引发真实的 NAND Flash 物理擦写。
连续高压写入：每个测试文件由一个 6MB 的首段基础数据块和 1~50 个随机大小（1KB-50MB）的附加数据块组成。更严苛的是，压测启用了强制缓存刷盘（fdatasync），要求所有写入数据立刻绕过系统缓存直接落盘。

压测现象与内核报错

开启强制刷盘进行测试后，刚完成极少量写入，程序便卡死，随后内核打出致命错误。通过分析相关的底层日志，观察到以下现象：

底层驱动频繁刷屏警告：Warn: #Cmd_25 (0x00...)=>(E: 0x0002)。
伴随出现无尽的信号相位调优动作打印：SDR PH(11), $$ PassPHs...。
最终系统抛出块设备级别的致命异常：blk_update_request: I/O error, dev mmcblk0, sector ... op 0x1:(WRITE)。

崩溃原因深度剖析

结合系统底层的驱动源码，分析出此次死机崩溃是由软硬两方面的三大瓶颈共同导致的：

SD卡硬件瓶颈（SLC Cache击穿）：高频、不可压缩的超大块随机数据写入瞬间耗尽了廉价 SD 卡的内部缓存。卡片被迫触发后台垃圾回收 (GC)，导致底层的多块写指令（Cmd 25: WRITE_MULTIPLE_BLOCK）响应出现秒级的剧烈延迟。
驱动超时设定过于苛刻：在底层的配置文件中，控制硬件响应等待的超时阈值设定得过短（仅为 1000 毫秒）。当卡片处于内部 GC 忙碌状态超过 1 秒时，驱动便失去耐心，强行判定通讯超时，从而抛出 E: 0x0002 错误。
致命的“相位重调”陷阱：在底层错误捕获逻辑中，一旦发生上述通讯超时，驱动竟然武断地判定这是高速信号发生了相位偏移，随后强行触发 Scan SDR Phase 流程。此时 SD 卡其实只是单纯忙于写盘，主控却对着忙碌的卡疯狂重新校准 SDR 时钟相位，最终导致时序全盘崩溃，抛出无法挽回的 I/O Error。

改进与优化建议

基于上述排查结果，为了提高系统在极限情况下的鲁棒性，建议采取以下详细的优化措施：

1. 修正底层驱动超时与错误恢复逻辑（治本）

放宽硬件超时阈值：定位到驱动配置头文件（例如 hal_card_platform_config.h），将其中的宏定义 WT_EVENT_RSP 由默认的 1000 放宽至 3000 或 5000 毫秒。这能给底层便宜的 SD 卡留出充足的后台 GC 搬运数据的时间，避免因短暂的卡顿引发严重的内核断联。
规避致命的相位陷阱：在底层错误分发层文件 ms_sdmmc_lnx.c 中（定位到包含 Scan SDR Phase 注释的 1385 行附近逻辑），必须增加对错误代码 eErr 的精确拦截。当 eErr == EV_STS_MIE_TOUT（纯粹的忙碌/响应超时）时，应当直接 return 报错或发起静默重传，严格禁止代码继续往下走到重调相位的流程。只有在明确捕获到 EV_STS_RSP_CERR（发生真正的物理 CRC 校验错）时，才允许启动这套耗时的相位扫描逻辑。

2. 修改设备树 (DTS)，降频并增强驱动能力（最快捷解法）

改动点：定位到平台的设备树文件（例如 infinity6f.dtsi）中的 sdmmc 节点。
关闭高速模式 (SD 3.0)：将 slot-support-sd30 = <1>,<0>,<0>; 修改为 <0>,<0>,<0>;。这会从硬件协商阶段直接禁用 UHS-I 超高速模式，迫使 SD 卡回退到 50MHz 的传统 High-Speed 模式。在此模式下，内核驱动根本不会执行那段充满陷阱的 SDR 相位扫描逻辑，系统稳定性将呈指数级提升。同时也强烈建议将 slot-max-clks 的最高频 200MHz 降频至 50MHz。
适度增强信号驱动能力 (Driving Strength)：如果由于主板走线过长或寄生电容过大导致高频信号波形畸变，可以在该节点下找到如下属性：
```
slot-clk-driving  = <2>,<2>,<0>;
slot-cmd-driving  = <2>,<2>,<0>;
slot-data-driving = <2>,<2>,<0>;
```
将表示外置 SD 卡槽（通常是第 0 个插槽的数值）的驱动能力档位从默认的 <2> 适度提升至 <3> 或 <4>（档位最大值为 7）。以此来提升物理层时钟与数据线边沿的陡峭程度，改善信号眼图。但请注意，盲目拉高驱动能力可能会引入电磁干扰 (EMI) 和过冲问题，建议配合示波器监测微调。

3. 应用层写盘平滑化调优 (sysctl 参数配置)

优化目标：在持续录像等业务中应禁用业务层的强制 sync，转而依靠 Linux 内核管理脏页（Dirty Pages）回写。然而，内核默认配置倾向于在内存中“攒一大波数据”再一口气刷盘，极易造成瞬时的巨量 I/O 爆发（波峰式挤压），直接冲垮廉价 SD 卡的内部缓冲。我们需要通过调整让内核“少吃多餐”，平滑且及早地往 SD 卡写数据。
需要调整的核心参数与建议值：
- vm.dirty_background_ratio：触发后台内核线程异步刷盘的脏页占总内存的百分比。建议从默认的 10 调低至 2 ~ 5，让系统在只积攒了极少量脏数据时就立刻开始慢慢向后台写盘。
- vm.dirty_ratio：触发所有产生写入动作的进程同步阻塞（强制交出 CPU 去刷盘）的硬上限百分比。建议从默认的 20 调低至 10 左右，以压低极限缓冲的危险水位。
- vm.dirty_writeback_centisecs：后台刷盘守护进程的唤醒巡视间隔（单位：百分之一秒，100 = 1秒）。建议从默认的 500 调低至 100 或 50，让内核更勤快地去搬运脏数据。
- vm.dirty_expire_centisecs：脏数据在内存中停留的最长允许老化时间（单位：百分之一秒）。建议从默认的 3000 (30秒) 调低至 500 (5秒) 或 1000 (10秒)。
如何修改：
- 临时生效（热修改调参测试）：通过终端直接下发命令：
```
sysctl -w vm.dirty_background_ratio=5
sysctl -w vm.dirty_ratio=10
sysctl -w vm.dirty_writeback_centisecs=100
sysctl -w vm.dirty_expire_centisecs=500
```
  (或者通过 echo 5 > /proc/sys/vm/dirty_background_ratio 方式写入)
- 永久生效（固化入固件）：将参数写入设备根文件系统的 /etc/sysctl.conf 文件中：
```
vm.dirty_background_ratio = 5
vm.dirty_ratio = 10
vm.dirty_writeback_centisecs = 100
vm.dirty_expire_centisecs = 500
```
  确保系统的 init 或 rc.local 启动脚本中带有 sysctl -p 指令，从而在每次开机时自动载入。

4. 硬件供电排查（硬件层）

排查重点：在执行高压满载写入的瞬间，通过示波器抓取 VDD_SD 引脚的电压波形。
修改方案：排查高压写入带来的瞬时大电流是否导致了 LDO 供电出现了纹波跌落。如确认存在压降，需考虑在电源侧增加滤波电容或更换更大带载能力的供电芯片。

补充：实际应用中是否建议使用 Sync？

结论：在 IPC 监控摄像机等高频写盘场景中，极其不推荐高频或逐块使用 sync / fdatasync。

压测中使用强制 sync 是为了刺探驱动底线的极端测试手段，但在实际落地业务中，滥用 sync 会带来灾难性后果：

引发严重的“写放大”(Write Amplification)：SD 卡内部的 NAND Flash 只能按块（Block，通常为 4MB 甚至更大）进行擦写。如果您每写入几十 KB 数据就调用一次 sync 强刷，SD 卡将被迫反复搬运、擦除并重写同一个物理大块。这会导致卡片读写性能断崖式暴跌，且极易引发超时卡死。
极速损耗 SD 卡寿命：消费级 SD 卡的 TLC/QLC 颗粒擦写寿命本身就十分有限（通常仅有几百到一千次 P/E）。高频强制落盘会迅速耗尽主控的磨损均衡（Wear Leveling）裕量，导致一张原本寿命达数年的卡在短短几周甚至几天内直接写废“变砖”。
正确的数据落盘姿势：
- 信任系统缓冲：绝大部分视音频流数据应当交由 Linux 内核的 Page Cache 脏页回写机制去处理，系统会自动将零碎数据聚合成大块后再一次性写给底层，大大降低 SD 卡 FTL 的负担。
- 业务对齐刷盘：如果确有如“录像切片索引表”这样防丢的关键元数据，应当在内存中先“攒大块”（例如按 1MB 边界对齐），随后再低频地调用一次 fsync()，切忌“碎文件强刷”。
- 硬件级掉电保护：如果是为了防止突发断电导致最后几秒录像丢失，更正统的解法是在硬件端加入超级电容（SuperCap）储能方案，在检测到外部掉电中断的最后几百毫秒内，再去执行一次总的 sync 安全收尾。

附录：压测工具源码 (`sd_stress.c`)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <time.h>
#include <sys/stat.h>
#include <sys/mount.h>
#include <errno.h>

#define FILE_F "/tmp/test_6M.bin"
#define FILE_F_SIZE (6 * 1024 * 1024)

typedef struct Task {
    void *data;
    size_t size;
    struct timespec gen_start; // 数据开始生成时间
    struct timespec gen_end;   // 数据生成完毕，准备入队时间
    int loop_idx;
    int chunk_idx;
    int total_chunks;
    struct Task *next;
} Task;

Task *queue_head = NULL;
Task *queue_tail = NULL;
int queue_size = 0;
#define MAX_QUEUE_SIZE 2

pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t queue_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t queue_not_full = PTHREAD_COND_INITIALIZER;

void *file_f_data = NULL;
char sd_dir[256] = "/mnt/sdcard";
int enable_sync = 0; // 同步开关
int max_loops = 0;   // 最大循环次数 (0表示无限)



// 获取时间戳之差（毫秒）
double diff_ms(struct timespec start, struct timespec end) {
    return (end.tv_sec - start.tv_sec) * 1000.0 + (end.tv_nsec - start.tv_nsec) / 1000000.0;
}

void enqueue(void *data, size_t size, struct timespec *t_start, struct timespec *t_end, int l_idx, int c_idx, int t_chunks) {
    Task *t = malloc(sizeof(Task));
    t->data = data;
    t->size = size;
    if (t_start) t->gen_start = *t_start;
    if (t_end) t->gen_end = *t_end;
    t->loop_idx = l_idx;
    t->chunk_idx = c_idx;
    t->total_chunks = t_chunks;
    t->next = NULL;

    pthread_mutex_lock(&queue_mutex);
    while (queue_size >= MAX_QUEUE_SIZE) {
        pthread_cond_wait(&queue_not_full, &queue_mutex);
    }

    if (queue_tail) {
        queue_tail->next = t;
        queue_tail = t;
    } else {
        queue_head = queue_tail = t;
    }
    queue_size++;
    pthread_cond_signal(&queue_cond);
    pthread_mutex_unlock(&queue_mutex);
}

Task *dequeue() {
    pthread_mutex_lock(&queue_mutex);
    while (queue_size == 0) {
        pthread_cond_wait(&queue_cond, &queue_mutex);
    }
    Task *t = queue_head;
    queue_head = t->next;
    if (queue_head == NULL) queue_tail = NULL;
    queue_size--;
    pthread_cond_signal(&queue_not_full); // 通知M队列有空位了
    pthread_mutex_unlock(&queue_mutex);
    return t;
}

// 快速伪随机数生成器（Xorshift32），比标准 rand() 快非常多
static inline unsigned int xorshift32(unsigned int *state) {
    unsigned int x = *state;
    x ^= x << 13;
    x ^= x >> 17;
    x ^= x << 5;
    *state = x;
    return x;
}

// 使用快速随机算法填充整个 buffer
void fill_random_bytes(void *buf, size_t size, unsigned int *seed) {
    unsigned int *ptr = (unsigned int *)buf;
    size_t words = size / sizeof(unsigned int);
    for (size_t i = 0; i < words; i++) {
        ptr[i] = xorshift32(seed);
    }
    unsigned char *cptr = (unsigned char *)(ptr + words);
    size_t rem = size % sizeof(unsigned int);
    if (rem > 0) {
        unsigned int tail = xorshift32(seed);
        for (size_t i = 0; i < rem; i++) {
            cptr[i] = (tail >> (i * 8)) & 0xFF;
        }
    }
}

void init_file_f() {
    file_f_data = malloc(FILE_F_SIZE);
    unsigned int seed = 123456789;
    fill_random_bytes(file_f_data, FILE_F_SIZE, &seed);
    
    int fd = open(FILE_F, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd < 0) {
        perror("Create F failed");
        exit(1);
    }
    write(fd, file_f_data, FILE_F_SIZE);
    close(fd);
    printf("[Init] F file created: %s (6MB)\n", FILE_F);
}

void *thread_m(void *arg) {
    srand(time(NULL));
    struct timespec t_f_ts;
    int current_loop = 0;
    
    while (max_loops == 0 || current_loop < max_loops) {
        current_loop++;
        
        // 2. 随机产生1KB-50MB数据 1-50次 (决定本轮的总块数)
        int repeat = (rand() % 50) + 1; // 1-50
        
        // 1. 每次循环开头，先将F送给W。F是预生成的，所以生成耗时算0
        clock_gettime(CLOCK_MONOTONIC, &t_f_ts);
        enqueue(file_f_data, FILE_F_SIZE, &t_f_ts, &t_f_ts, current_loop, 0, repeat);

        for (int i = 0; i < repeat; i++) {
            size_t size = (rand() % (50 * 1024 * 1024 - 1024 + 1)) + 1024;
            
            struct timespec t1, t2;
            clock_gettime(CLOCK_MONOTONIC, &t1); // 记录生成开始时间
            
            void *data = malloc(size);
            if (data) {
                unsigned int seed = rand();
                fill_random_bytes(data, size, &seed);
                clock_gettime(CLOCK_MONOTONIC, &t2); // 记录生成完毕时间
                enqueue(data, size, &t1, &t2, current_loop, i + 1, repeat);
            }
        }

        // 3. 随机等待 0-1000ms
        int wait_ms = rand() % 1001;
        usleep(wait_ms * 1000);
    }
    
    // 发送退出信号给 W
    enqueue(NULL, 0, NULL, NULL, 0, 0, 0);
    return NULL;
}

void *thread_w(void *arg) {
    char file_path[512];
    unsigned int file_idx = 0;
    int fd = -1;

    while (1) {
        Task *t = dequeue();
        
        // 收到退出信号
        if (t->data == NULL && t->size == 0) {
            free(t);
            break;
        }

        int is_full = 0;

        // [F] 数据，作为新文件起始
        if (t->data == file_f_data) {
            if (fd >= 0) {
                close(fd);
                fd = -1;
            }
            snprintf(file_path, sizeof(file_path), "%s/stress_%u.bin", sd_dir, file_idx);
            fd = open(file_path, O_CREAT | O_WRONLY | O_TRUNC, 0644);
            if (fd < 0) {
                perror("Open SD file err");
                if (errno == ENOSPC) is_full = 1;
            } else {
                file_idx++;
            }
        }

        // 开始写入前的时间戳
        struct timespec w_start, w_end, sync_end;
        clock_gettime(CLOCK_MONOTONIC, &w_start);

        if (fd >= 0) {
            ssize_t ret = write(fd, t->data, t->size);
            clock_gettime(CLOCK_MONOTONIC, &w_end); // 写入系统缓存完成后的时间戳

            double sync_ms = 0.0;
            if (ret >= 0 && enable_sync) {
                fdatasync(fd);
                clock_gettime(CLOCK_MONOTONIC, &sync_end);
                sync_ms = diff_ms(w_end, sync_end);
            }

            if (ret < 0 || (size_t)ret < t->size) {
                perror("Write err / Disk full");
                is_full = 1;
            } else {
                double m_gen_ms = diff_ms(t->gen_start, t->gen_end);
                double wait_ms = diff_ms(t->gen_end, w_start);
                double w_ms = diff_ms(w_start, w_end);
                
                if (enable_sync) {
                    printf("[W] [Lp %d:%d/%d] Appended %zu B to %s | M_Gen: %.3f ms | Wait: %.3f ms | W(Cache): %.3f ms | Sync: %.3f ms\n", 
                            t->loop_idx, t->chunk_idx, t->total_chunks, t->size, file_path, m_gen_ms, wait_ms, w_ms, sync_ms);
                } else {
                    printf("[W] [Lp %d:%d/%d] Appended %zu B to %s | M_Gen: %.3f ms | Wait: %.3f ms | W_Time: %.3f ms\n", 
                            t->loop_idx, t->chunk_idx, t->total_chunks, t->size, file_path, m_gen_ms, wait_ms, w_ms);
                }
            }
        }

        if (is_full) {
            printf("[W] SD Card likely full. Deleting all test files...\n");
            if (fd >= 0) {
                close(fd);
                fd = -1;
            }
            char cmd[512];
            snprintf(cmd, sizeof(cmd), "rm -f %s/stress_*.bin", sd_dir);
            system(cmd);
            file_idx = 0;
        }

        if (t->data != file_f_data) {
            free(t->data);
        }
        free(t);
    }
    
    if (fd >= 0) close(fd);
    printf("[W] Exit signal received. Thread W stopped.\n");
    return NULL;
}

int main(int argc, char **argv) {
    char *dev = "/dev/mmcblk0p1";
    if (argc > 1) dev = argv[1];
    if (argc > 2) strncpy(sd_dir, argv[2], sizeof(sd_dir) - 1);
    if (argc > 3) enable_sync = atoi(argv[3]);
    if (argc > 4) max_loops = atoi(argv[4]);

    printf("--- SD Stress Test ---\n");
    printf("Device: %s\n", dev);
    printf("Mount Dir: %s\n", sd_dir);
    printf("Force Sync: %s\n", enable_sync ? "ON" : "OFF");
    printf("Max Loops: %d (0 = Infinite)\n", max_loops);
    printf("----------------------\n");

    mkdir(sd_dir, 0755);
    if (mount(dev, sd_dir, "vfat", 0, NULL) == 0) {
        printf("[Init] Mounted %s to %s\n", dev, sd_dir);
    } else {
        perror("[Init] Mount warning");
    }

    init_file_f();

    pthread_t tm, tw;
    pthread_create(&tm, NULL, thread_m, NULL);
    pthread_create(&tw, NULL, thread_w, NULL);

    pthread_join(tm, NULL);
    pthread_join(tw, NULL);
    
    return 0;
}

mipi屏幕调试记录

2025-05-26T00:00:00+00:00

先检查接线，是顺序还是反序，P和N有没有反接，确认线序之后再配置，配置的地方每个平台不尽相同
检查管脚复用，确认I/O的输出功能是MIPI，一般配置的地方在dts、驱动或者专门控制寄存器的脚本之类
确认屏厂有提供以下参数

vsa: 垂直同步脉冲的有效时间，表示屏幕完成一帧刷新后，重新开始垂直同步的信号持续时间（通常以行数计算）
vbp: 垂直后沿，指垂直同步脉冲结束到有效图像数据开始之间的间隔时间（行数）。用于留出信号稳定时间
vfp: 垂直前沿，指一帧图像数据结束到下一个垂直同步脉冲开始之间的间隔时间（行数）。与VBP共同控制帧率
vact: 垂直有效时间，表示屏幕中实际显示图像的行数
hs: 水平同步脉冲，表示每行像素扫描开始时触发的同步信号，用于控制行扫描的起始
hbp: 水平后沿，水平同步脉冲结束到有效像素数据开始之间的间隔时间
hfp: 水平前沿，一行像素数据结束到下一个水平同步脉冲开始之间的间隔时间
hact: 水平有效时间，表示每行中实际显示图像的像素数
fps: 帧率，表示屏幕每秒刷新的帧数
clk: MIPI DSI输出的clock，一般为htotal*vtotal*fps*bpp/lane
初始化序列

将以上参数填入屏幕初始化组件，可能位于dts、驱动、配置文件或者是直接写在代码里面
点屏。一般是跑一个fb demo，使其输出一个画面
如果屏幕没有亮起，首先检查背光和复位是否正常，然后再检查vcc是否正常，最后检查mipi的信号是否正常
如果显示有异常，需要调整上述的各项参数

kernel panic 的一些调试相关内容

2024-02-19T00:00:00+00:00

关键信息

ethtool_check_ops+0x18/0x38
函数名称：ethtool_check_ops
函数长度：0x38
偏移位置：0x18
函数基址：通过system.map或/proc/kallsyms查询

寻找出错位置

# 前置条件：CONFIG_DEBUG_INFO=y
# 0xFFFF800011AD4328 由上文的函数基址+偏移位置得出，也即是PC寄存器当前值
aarch64-linux-gnu-addr2line -C -f -e vmlinux 0xFFFF800011AD4328

调试手段

#include <linux/bug.h>

dump_stack(); // 打印栈信息

// 产生panic，并调用dump_stack打印栈信息
BUG();
BUG_ON(condition);

// 调用dump_stack但不产生panic
WARN(condition,format...)
WARN_ON(condition)
WARN_ONCE(condition, format...)
WARN_ON_ONCE(condition)

一些相关寄存器

R15：又叫程序计数器（Program Counter）PC，PC主要用于存放CPU取指的地址。

R14：又叫链接寄存器（Link register）LR，LR主要用于存放函数的返回地址，即当函数返回时，知道自己该回到哪儿去继续运行。

R13：又叫堆栈指针寄存器（Stack pointer）SP，SP通常用于保存堆栈地址，在使用入栈和出栈指令时，SP中的堆栈地址会自动的更新。

R12：又叫内部过程调用暂存寄存器（Intra-Procedure-call scratch register）IP，主要用于暂存SP。

R11：又叫帧指针寄存器（Frame pointer）FP，通常指向一个函数的栈帧底部，表示一个函数栈的开始位置。

AIDL for HAL in Android11+

2024-01-14T00:00:00+00:00

以IR这个模块为例
实现部分: aosp\hardware\libhardware\modules\consumerir
这部分最后生成动态库，供接口调用
接口部分：aosp\hardware\interfaces\ir
这部分最后生成服务，供上层应用调用

先看实现部分，这部分以c实现，接近传统的Linux编程
首先是一系列的实现函数，然后用两个结构体串联起来，以供后续使用
第一个结构体是struct hw_module_methods_t

static struct hw_module_methods_t consumerir_module_methods = {
    .open = consumerir_open,
};

这个结构体是用来初始化这个模块的，open函数会打开这个模块并初始化，然后返回这个模块的指针，上层拿到这个指针就可以工作了

另外一个是consumerir_module_t

consumerir_module_t HAL_MODULE_INFO_SYM = {
    .common = {
        .tag                = HARDWARE_MODULE_TAG,
        .module_api_version = CONSUMERIR_MODULE_API_VERSION_1_0,
        .hal_api_version    = HARDWARE_HAL_API_VERSION,
        .id                 = CONSUMERIR_HARDWARE_MODULE_ID,
        .name               = "Demo IR HAL",
        .author             = "The Android Open Source Project",
        .methods            = &consumerir_module_methods,
    },
};

HAL_MODULE_INFO_SYM是一个宏定义，具体作用是用来定位模块入口的，当这个动态库被打开之后，就可以用dlsym来定位这个宏定义的地址，从而确定这个模块的入口地址
CONSUMERIR_HARDWARE_MODULE_ID是这个模块的ID，系统通过这个ID来匹配是不是目标模块

再看接口部分，这部分以cpp为主
首先是aidl文件，这部分定义了上层可以访问的一些接口、结构体变量之类的
然后是cpp文件，这部分是接口服务的主体部分

ConsumerIr::ConsumerIr() {
    const hw_module_t *hw_module = NULL;

    int ret = hw_get_module(CONSUMERIR_HARDWARE_MODULE_ID, &hw_module);
    if (ret != 0) {
        ALOGE("hw_get_module %s failed: %d", CONSUMERIR_HARDWARE_MODULE_ID, ret);
        return;
    }
    ret = hw_module->methods->open(hw_module, CONSUMERIR_TRANSMITTER, (hw_device_t **) &mDevice);
    if (ret < 0) {
        // note - may want to make this a fatal error - otherwise the service will crash when it's used
        ALOGE("Can't open consumer IR transmitter, error: %d", ret);
        // in case it's modified
        mDevice = nullptr;
    }
}

在上面的构造函数里，通过hw_get_module这个函数来打开目标模块，传递的CONSUMERIR_HARDWARE_MODULE_ID正是上面定义的ID，这里对应上了
然后接下来的open就是上面实现的open，这样就可以拿到目标指针了，之后就可以正常访问这个模块了

hw_get_module在aosp\hardware\libhardware\hardware.c定义，实际上是调用hw_module_exists来寻找目标模块的
目标模块的命名和存放位置必须符合HAL的规则，当找到符合规则的模块之后，进入用load函数开始加载
首先要用dlopen打开，然后用dlsym定位模块的入口，这个入口在上面用HAL_MODULE_INFO_SYM定义

/* Get the address of the struct hal_module_info. */
const char *sym = HAL_MODULE_INFO_SYM_AS_STR;
hmi = (struct hw_module_t *)dlsym(handle, sym);
if (hmi == NULL) {
    ALOGE("load: couldn't find symbol %s", sym);
    status = -EINVAL;
    goto done;
}

移植Ubuntu到嵌入式Linux平台

2022-03-19T00:00:00+00:00

在宿主机上下载基本包，然后在开发板进行安装

# 下载
sudo debootstrap --arch=arm64 --foreign --components=main,restricted,universe,multiverse \
    --exclude=apt-transport-https,gcc --include=openssh-server,vim bionic workspace \
    https://mirrors.cloud.tencent.com/ubuntu-ports
# 下载版本为bionic的Ubuntu到workspace这个目录，下载地址可以根据实际情况替换
# Ubuntu的版本代号可前往https://wiki.ubuntu.com/Releases查看

# 将workspace复制到开发板上，然后安装
LANG=C.UTF-8 LANGUAGE==C.UTF-8 LC_ALL=C.UTF-8 \
    chroot workspace /debootstrap/debootstrap --second-stage --no-check-gpg

或者，直接在开发板上下载安装

debootstrap --arch=arm64 --components=main,restricted,universe,multiverse \
    --exclude=apt-transport-https,gcc --include=openssh-server,vim bionic workspace \
    https://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports

安装完成后，在开发板进入Ubuntu，开始进行配置

chroot workspace

配置网络参考

cat /etc/netplan/00-installer-config.yaml
network:
  ethernets:
    eth0:
      dhcp4: true
  version: 2

如果需要桌面接管网络，则如下配置

cat /etc/netplan/00-installer-config.yaml
network:
  version: 2
  renderer: NetworkManager
  
diff /etc/NetworkManager/NetworkManager.conf
-managed=false
+managed=true

添加默认dns

diff /etc/systemd/resolved.conf
[Resolve]
-#DNS=
+DNS=8.8.8.8 114.114.114.114 119.29.29.29 223.6.6.6 180.76.76.76 1.1.1.1 1.2.4.8

# 使用systemd-resolve --status 查看dns状态

开机打印IP 参考

cat /lib/systemd/system/getip.service
[Unit]
Description=get ip
After=systemd-networkd.service

[Service]
Type=idle
ExecStart=/etc/getip.sh

[Install]
WantedBy=multi-user.target

#===========================#

cat /etc/getip.sh
#!/bin/sh

ip=`hostname -I`

while [ -z $ip ]
do
        ip=`hostname -I`
        sleep 1
done

echo ============== $ip============== > /dev/console

#===========================#
# 使能
systemctl enable /lib/systemd/system/getip.service

修改串口自动登录root 参考

cp /lib/systemd/system/serial-getty\@.service \
/lib/systemd/system/serial-getty\@ttyS0.service
diff /lib/systemd/system/serial-getty\@ttyS0.service
-ExecStart=-/sbin/agetty -o '-p -- \\u' --keep-baud 115200,38400,9600 %I $TERM
+ExecStart=-/sbin/agetty -a root --keep-baud 1500000,115200,38400 %I $TERM
# 使能
systemctl enable /lib/systemd/system/serial-getty\@ttyFIQ0.service

修改sshd允许root登录参考

diff /etc/ssh/sshd_config
-#PermitRootLogin prohibit-password
+PermitRootLogin yes

扩展rootfs

cat /lib/systemd/system/resize-helper.service
[Unit]
Description=Resize root filesystem to fit available disk space
After=systemd-remount-fs.service

[Service]
Type=oneshot
ExecStart=/sbin/resize2fs /dev/mmcblk0p6
ExecStartPost=/bin/systemctl disable resize-helper.service

[Install]
WantedBy=local-fs.target

#===========================#
# 使能
systemctl enable /lib/systemd/system/resize-helper.service

禁止休眠（可选）

systemctl disable sleep.target suspend.target hibernate.target hybrid-sleep.target

挂载user分区（如果是桌面环境可以跳过）

cat /etc/fstab

/dev/mmcblk0p8 /mnt ext4 defaults 0 0

配置系统

# 配置locales
dpkg-reconfigure locales
# 配置时区
dpkg-reconfigure tzdata
# 更换APT源，选择适合的源，为避免错误，先用HTTP协议的
vi /etc/apt/sources.list
# 然后更新证书
apt update && apt install apt-transport-https ca-certificates
# 修改/etc/apt/sources.list，启用HTTPS的源，更新整个系统
apt update && apt upgrade -y

退出，然后打包

dd of=bionic.ext4 bs=1M seek=6144 count=0 # seek是rootfs分区的大小
mke2fs -t ext4 -d workspace bionic.ext4
tune2fs -c 0 -i 0 bionic.ext4
resize2fs -M bionic.ext4

把workspace备份到宿主机以便后续开发

tar cf bionic.tar workspace
scp bionic.tar user@IP:.

把bionic.ext4复制到宿主机然后进行烧录到开发板

scp bionic.ext4 user@IP:.

搞定

在kernel中增加rs485的读写控制

2022-01-24T00:00:00+00:00

一些rs485的IC通过gpio来控制读写方向，本文基于8250的驱动，讲讲在kernel中如何通过控制gpio来控制rs485的读写方向。

首先是增加定义：

#include <linux/gpio.h>
#include <linux/timer.h>

#define RS485_NR        CONFIG_SERIAL_8250_NR_UARTS
#define RS485_GPIO_DEF  GPIO0_A3

typedef struct {
	ktime_t ktime;
	struct hrtimer timer;
	struct uart_port *port;
} rs485_ctl_t;

rs485_ctl_t rs485_ctl[RS485_NR];

然后在serial8250_init_port中初始化：

int i = port->line;

// 这里用到了struct uart_port中的空闲变量unused[0]来保存gpio
port->unused[0] = RS485_GPIO_DEF;
port->rs485_config = serial8250_rs485_config;

hrtimer_init(&rs485_ctl[i].timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

rs485_ctl[i].timer.function = serial8250_rs485_stop_tx_timeout;
rs485_ctl[i].port = port;

接着实现在init中所涉及的函数：

// 这里通过struct serial_rs485的padding[0]在应用层传递gpio，如果没有，就用默认的gpio
int serial8250_rs485_config(struct uart_port *port, struct serial_rs485 *rs485)
{
	unsigned gpio;

	memcpy(&port->rs485, rs485, sizeof(struct serial_rs485));

	gpio = (unsigned)port->rs485.padding[0];

	if (gpio > 0)
		port->unused[0] = gpio;
	else
		gpio = (unsigned)port->unused[0];

	if (port->rs485.flags & SER_RS485_ENABLED)
		return serial8250_rs485_gpio_init(gpio);

	return -EINVAL;
}

static int serial8250_rs485_gpio_init(unsigned gpio)
{
	int ret;

	if (gpio_is_valid(gpio))
	{
		ret = gpio_request(gpio, "RS485 R/W Switch GPIO");
		if (ret)
			return ret;
		else
		{
			gpio_direction_output(gpio, 0);
			return 0;
		}
	}

	return -EBUSY;
}

static enum hrtimer_restart serial8250_rs485_stop_tx_timeout(struct hrtimer *t)
{
	rs485_ctl_t *rs485_ctl =
		container_of(t, rs485_ctl_t, timer);
	struct uart_port *port = rs485_ctl->port;
	unsigned gpio = (unsigned)port->unused[0];

	if (serial8250_tx_empty(port))
	{
		gpio_set_value(gpio, 0);
		return HRTIMER_NORESTART;
	}
	else
	{
		hrtimer_forward_now(t, rs485_ctl->ktime);
		return HRTIMER_RESTART;
	}
}

跟着在serial8250_start_tx中控制gpio来控制读写方向

// 发送数据前拉高gpio
if (port->rs485.flags & SER_RS485_ENABLED)
	serial8250_rs485_start_tx((unsigned)port->unused[0]);

// 发送完成后拉低gpio
if (port->rs485.flags & SER_RS485_ENABLED)
{
	int i = port->line;

	rs485_ctl[i].port = port;
	rs485_ctl[i].ktime = ktime_set(0, HZ * 1000);

	hrtimer_start(&rs485_ctl[i].timer,
	                rs485_ctl[i].ktime, HRTIMER_MODE_REL);
}

在关闭应用程序时，释放gpio

if (port->rs485.flags & SER_RS485_ENABLED)
	serial8250_rs485_gpio_free((unsigned)port->unused[0]);

实现相关的函数

static inline void serial8250_rs485_start_tx(unsigned gpio)
{
	gpio_set_value(gpio, 1);
}

static inline void serial8250_rs485_stop_tx(unsigned gpio)
{
	gpio_set_value(gpio, 0);
}

static inline void serial8250_rs485_gpio_free(unsigned gpio)
{
	if (gpio_is_valid(gpio))
	{
		gpio_set_value(gpio, 0);
		gpio_free(gpio);
	}

}

最后在serial8250_register_8250_port注释默认的rs485_config

// uart->port.rs485_config	= up->port.rs485_config;

在Linux中将phy连接到fixed phy bus

2021-01-11T00:00:00+00:00

开发板上放了个交换机的phy，而且走的不是MDIO，而是SMI，驱动无法识别成有效phy，导致网络不通。以下是修改驱动把phy连接到fixed bus，从而建立kernel与phy之间的通信。本次修改基于Linux 3.x，没有启用dts。

首先把phy添加到fixed驱动里面

// phy的属性
struct fixed_phy_status status = {
	.link = 1, // 是否启用
	.speed = 1000, // 速度
	.duplex = 1, // 全双工
};

// 因为识别不到phy，phy_addr给一个系统还没有注册的值就好，这里是0
fixed_phy_add(PHY_POLL, phy_addr, status);

在fixed bus里面找到刚刚添加的phy

// 这里的bus是fixed bus，在fixed bus驱动里面，定义为
// struct fixed_mdio_bus *fmb；
// bus = fmb->mii_bus；
phy = get_phy_device(bus, phy_addr, false);

把找到的phy注册设备

phy_device_register(phy);

注册成功后，在后续驱动的phy_connect()就可以正常连接到phy了，要注意的是传递给phy_connect的bus_id是fixed bus的id，而不是实际的bus id。

ps：高版本的Linux通常都启用dts，通过dts配置phy连接到fixed bus网上已有相关blog，这里不再叙述。

对不同的IP指定访问路由/网卡

2018-11-29T00:00:00+00:00

Step 1. 设定IP地址和网关

ip addr 192.168.1.11/24 dev ens33
将192.168.1.11替换成你的IP地址，将ens33替换成你的网卡名字
如果是DHCP动态获取IP，跳过这一步

Step 2. 设定默认网关

sudo ip route add default via 192.168.1.1 dev ens33

Step 3. 对特殊IP指定路由/网关

sudo ip route add 192.168.0.11 via 192.168.1.254 dev ens33

Step 4. 结论

在例子中，如果你添加了0网段的IP但192.168.0.11不在局域网中这样是无法访问的，但是指定192.168.0.11通过默认网关192.168.1.254则可以正常访问。

对不同的主机使用不同的公钥连接

2017-10-07T00:00:00+00:00

Step 1. 首先生成公钥

ssh-keygen -t rsa -b 4096 -C "<user@server>" -f ~/.ssh/<filename>
# 将user@server和filename有意义的字符串。此时密钥对就会在指定路径生成。

Step 2. 将<filename>.pub 拷贝到远程主机上

ssh-copy-id -i ~/.ssh/<filename>.pub <user@server>
# 远程主机会要求你登录。

Step 3. 拷贝完成后，在~/.ssh/config作出如下配置：

host <alias name>
    user <your name>
    hostname <server name>
    port <ssh port>
    identityfile ~/.ssh/<filename>

例如：

host me
    user test
    hostname chowe.one
    port 22
    identityfile ~/.ssh/test

保存后执行

ssh me

这样就会以你设置的密钥登陆到远程主机上。

同样，也可以用于scp风格的指令中：

scp me:path/to/filename ~/path/to/filename

如果想要指定某个主机使用特定的密钥在~/.ssh/config作出如下配置即可：

host example.com
    identityfile ~/.ssh/xxx_rsa

host *
    identityfile ~/.ssh/id_rsa

如果密钥带有passphrase而你又不想每次都要输入，可以使用ssh agent

eval $(ssh-agent)
ssh-add ~/.ssh/xxx_rsa

此时只有输入一次passphrase就可以了，当然，这个只针对当前shell起作用