phonerail/firmware/components/phonerail_hal/sim/hal_gpio_sim.c

/* GPIO 的假实现。宿主机专用。 */
#include <assert.h>
#include <string.h>

#include "sim_hal.h"

typedef struct {
    bool            configured;
    hal_gpio_mode_t mode;
    int             level;
    uint32_t        writes;
    uint32_t        seq; /* 最后一次被写时的全局序号，0 = 没写过 */
    uint64_t        rise_us; /* 最后一次 0→1 的虚拟时刻（µs），0 = 没有过 */
    bool            ext;     /* 外部世界在驱这根线（`sim_gpio_drive`），跨 config 保持 */
    int             ext_level;
    bool            held;    /* hal_gpio_hold：引脚锁在 pad 上，`level` 只是寄存器 */
    int             pad;     /* 锁着时引脚上的电平 */
    uint32_t        holds;   /* 被锁过几次 */
} pin_t;

static sim_gpio_hook_t s_hook;

static pin_t s_pin[SIM_GPIO_PINS];
static uint32_t s_seq; /* 全局写计数，从 1 开始发号 */

void sim_gpio_reset_internal(void); /* 只给 sim_hal_reset() 用 */

/* 假 74HC595 链的窃听口（sim_sr595.c）。没 attach 过就是个空动作。
   放在这里而不是让测试自己数边：移位链要看的是**电平的跳变**，
   而 hal_gpio_write() 写同一个值也会计一次 writes。 */
void sim_sr595_gpio_hook(int pin, int level);

/* 假 TCA9548A 的 `MUX_RST#` 窃听口（hal_i2c_sim.c）。拉低 = 通道全关。
   没挂 mux 就是个空动作。 */
void sim_mux_gpio_hook(int pin, int level);

void sim_gpio_reset_internal(void)
{
    memset(s_pin, 0, sizeof(s_pin));
    s_seq = 0;
    s_hook = NULL;
}

static bool valid(int pin) { return pin >= 0 && pin < SIM_GPIO_PINS; }

/* 引脚上的电平：锁着看 pad，没锁看寄存器。 */
static int pad_of(const pin_t *p) { return p->held ? p->pad : p->level; }

/* 引脚真的变了才通知外部世界（假 595 / 假 mux / 测试的钩子）。 */
static void notify(int pin, int was)
{
    pin_t    *p = &s_pin[pin];
    const int now = pad_of(p);
    if (now == was) {
        return;
    }
    if (was == 0 && now == 1) {
        p->rise_us = hal_time_now_us();
    }
    sim_sr595_gpio_hook(pin, now);
    sim_mux_gpio_hook(pin, now);
    if (s_hook != NULL) {
        s_hook(pin, now);
    }
}

hal_err_t hal_gpio_config(int pin, hal_gpio_mode_t mode)
{
    if (!valid(pin)) {
        return HAL_ERR_ARG;
    }
    pin_t *p = &s_pin[pin];
    if (p->held) {
        /* 锁着：方向与寄存器照改，引脚不动（ESP 的 gpio_hold 就是这样）。 */
        p->configured = true;
        p->mode = mode;
        p->level = 0;
        return HAL_OK;
    }
    p->configured = true;
    p->mode = mode;
    /* 上拉输入没人驱动时读回高电平 —— 五路 FLT/PG 都是开漏 + 上拉，
       「没有故障」在假板子上也必须是 1，不然测试会把默认 0 当成一直有故障。 */
    p->level = (mode == HAL_GPIO_INPUT_PULLUP) ? 1 : 0;
    /* 外部驱着的线，配成输入之后读到的是外部电平 —— 真板上刀片把 `PRSNT#` 短到地，
       与 ESP32 什么时候配这个脚无关（A15：启动序列自己配脚、配完立刻读）。 */
    if (mode != HAL_GPIO_OUTPUT && p->ext) {
        p->level = p->ext_level;
    }
    /* 配成输出的那一刻引脚就开始驱动了（ESP-IDF 的 gpio_config 也是这个行为，
       输出寄存器复位值 0）。`KEY_OE#` 正是靠这一条：配成输出 = 输出立刻使能，
       所以 sr595_init() 必须等安全值锁存完了再配它。 */
    if (mode == HAL_GPIO_OUTPUT) {
        sim_sr595_gpio_hook(pin, p->level);
        sim_mux_gpio_hook(pin, p->level);
    }
    return HAL_OK;
}

hal_err_t hal_gpio_write(int pin, int level)
{
    if (!valid(pin) || !s_pin[pin].configured || s_pin[pin].mode != HAL_GPIO_OUTPUT) {
        return HAL_ERR_ARG;
    }
    pin_t *p = &s_pin[pin];
    if (p->held) {
        p->level = level ? 1 : 0; /* 只改寄存器；writes 不计 —— 线上什么都没发生 */
        return HAL_OK;
    }
    const int was = p->level;
    p->level = level ? 1 : 0;
    p->writes++;
    p->seq = ++s_seq;
    if (was == 0 && p->level == 1) {
        p->rise_us = hal_time_now_us();
    }
    sim_sr595_gpio_hook(pin, p->level);
    sim_mux_gpio_hook(pin, p->level);
    if (s_hook != NULL) {
        s_hook(pin, p->level);
    }
    return HAL_OK;
}

hal_err_t hal_gpio_hold(int pin, bool on)
{
    if (!valid(pin)) {
        return HAL_ERR_ARG;
    }
    pin_t *p = &s_pin[pin];
    if (on) {
        if (!p->held) {
            p->pad = p->level;
            p->held = true;
            p->holds++;
        }
        return HAL_OK;
    }
    if (p->held) {
        const int was = p->pad;
        p->held = false;
        notify(pin, was);
    }
    return HAL_OK;
}

void sim_gpio_preheld(int pin, int level)
{
    assert(valid(pin));
    pin_t *p = &s_pin[pin];
    p->held = true;
    p->pad = level ? 1 : 0;
    p->level = 0;
}

bool sim_gpio_held(int pin) { return valid(pin) && s_pin[pin].held; }

hal_err_t hal_gpio_read(int pin, int *level)
{
    if (!valid(pin) || !s_pin[pin].configured || level == NULL) {
        return HAL_ERR_ARG;
    }
    *level = pad_of(&s_pin[pin]);
    return HAL_OK;
}

void sim_gpio_drive(int pin, int level)
{
    assert(valid(pin));
    /* 外部驱一个输出脚 = 打架，测试写错了。**没配过的脚可以驱**：外部世界不等固件
       （电平记下来，配成输入的那一刻生效）。 */
    assert(!s_pin[pin].configured || s_pin[pin].mode != HAL_GPIO_OUTPUT);
    s_pin[pin].ext = true;
    s_pin[pin].ext_level = level ? 1 : 0;
    if (s_pin[pin].configured) {
        s_pin[pin].level = level ? 1 : 0;
    }
}

int sim_gpio_level(int pin)
{
    if (!valid(pin)) {
        return -1;
    }
    if (s_pin[pin].held) {
        return s_pin[pin].pad; /* 锁着的脚即使这一条命还没配过，线上也是有电平的 */
    }
    if (!s_pin[pin].configured) {
        return -1;
    }
    return s_pin[pin].level;
}

uint32_t sim_gpio_writes(int pin) { return valid(pin) ? s_pin[pin].writes : 0; }

uint32_t sim_gpio_write_seq(int pin) { return valid(pin) ? s_pin[pin].seq : 0; }

uint64_t sim_gpio_rise_us(int pin) { return valid(pin) ? s_pin[pin].rise_us : 0; }

void sim_gpio_set_hook(sim_gpio_hook_t fn) { s_hook = fn; }