【IF-SAFE-07】SMU故障管理 - 双域架构与FSP

IF-SAFE-07 SMU故障管理

【IF-SAFE-07】SMU故障管理 – 双域架构与FSP

英飞凌AURIX™ TC3xx功能安全专题第七篇。本文深入解析Safety Management Unit (SMU)的工作原理，涵盖双域架构设计、FSP故障信号协议、告警分类与响应机制、MCAL配置实践，为构建符合ISO 26262要求的故障管理系统提供完整指南。本文约12000字，建议收藏。

系列导航

图0：本文内容思维导图

一、为什么需要SMU

1.1 功能安全对故障管理的要求

根据ISO 26262标准，安全关键系统必须具备故障检测、故障响应、故障恢复三大能力：

┌─────────────────────────────────────────────────────────────────────┐
│ ISO 26262 故障管理要求 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 1. 故障检测 (Fault Detection) │
│ └─ 硬件自检、软件监控、冗余比较 │
│ │
│ 2. 故障响应 (Fault Reaction) │
│ ├─ 立即动作：复位、看门狗触发 │
│ ├─ 延迟动作：NMI、应用层回调 │
│ └─ 报告机制：日志记录、状态上报 │
│ │
│ 3. 故障恢复 (Recovery) │
│ ├─ 自动恢复：故障清除后恢复正常 │
│ └─ 诊断恢复：软件介入处理 │
│ │
└─────────────────────────────────────────────────────────────────────┘

1.2 SMU在系统中的位置

图1：SMU双域架构全景图

SMU (Safety Management Unit) 是TC3xx芯片内部的集中式故障管理模块，负责：

1.3 与SCU/PMIC的联动

┌─────────────────────────────────────────────────────────────────────┐
│ TC3xx 故障管理联动机制 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ CPU │ │ DMA │ │ ADC │ │ CAN │ │
│ │ Trap │ │ Error │ │ Error │ │ Error │ │
│ └───┬─────┘ └───┬─────┘ └───┬─────┘ └───┬─────┘ │
│ │ │ │ │ │
│ └───────────────┴───────────────┴───────────────┘ │
│ │ │
│ ┌──────────▼──────────┐ │
│ │ SMU │ │
│ │ Safety Management │ │
│ │ Unit │ │
│ └──────────┬──────────┘ │
│ │ │
│ ┌──────────────────┼──────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ SCU │ │ ErrorPin │ │ Application│ │
│ │ System Reset│ │ (External)│ │ Callback │ │
│ └─────────────┘ └──────┬──────┘ └─────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ PMIC │ │
│ │ TLF35584等 │ │
│ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘

二、双域架构详解

2.1 Safety Domain vs Application Domain

图2：TC3xx Safety Domain与Application Domain架构

TC3xx采用双域架构实现安全与应用分离：

2.2 Safety Island安全岛

Safety Island是TC3xx芯片内部的一个独立子系统：

┌─────────────────────────────────────────────────────────────────────┐
│ Safety Island 内部结构 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Safety Island │ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ HSM │ │ Safety │ │ PMIC │ │ │
│ │ │ (ARM │ │ SCU │ │ Interface │ │ │
│ │ │ Cortex-M) │ │ │ │ │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ │ │ │ │ │ │
│ │ └──────────────────┼──────────────────┘ │ │
│ │ │ │ │
│ │ ┌──────▼──────┐ │ │
│ │ │ Safety │ │ │
│ │ │ WDT x2 │ │ │
│ │ └─────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
│ 主要功能： │
│ • 独立于主CPU的安全监控 │
│ • 加密/解密、安全通信 │
│ • 完整性校验 (Secure Boot) │
│ • 看门狗喂狗 │
│ │
└─────────────────────────────────────────────────────────────────────┘

2.3 域间通信机制

双域之间通过受控接口进行通信：

2.4 硬件隔离机制

┌─────────────────────────────────────────────────────────────────────┐
│ 硬件隔离层级 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ Level 1: 电源/时钟隔离 │
│ ├─ Safety Domain 可独立供电 │
│ └─ Safety Domain 可独立时钟 │
│ │
│ Level 2: 总线访问隔离 │
│ ├─ Safety域寄存器映射到独立地址空间 │
│ └─ 应用域无法直接访问Safety关键寄存器 │
│ │
│ Level 3: 中断/陷阱隔离 │
│ ├─ Safety域产生独立的NMI/Trap │
│ └─ 与应用域中断向量表物理分离 │
│ │
│ Level 4: 复位隔离 │
│ ├─ Safety域可独立复位应用域 │
│ └─ 应用域无法复位Safety域 │
│ │
└─────────────────────────────────────────────────────────────────────┘

三、FSP故障信号协议

3.1 FSP概述

FSP (Fault Signaling Protocol) 是SMU与外部PMIC通信的标准协议，用于：

• 通知外部PMIC芯片内部故障状态
• 触发PMIC进入安全状态（如 Limp Home 模式）
• 实现系统级安全响应协同

3.2 FSP状态机

图3：FSP状态机与时序图

状态定义：

状态转换条件：

// FSP状态转换伪代码
typedef enum {
SMU_FSP_NORMAL = 0,
SMU_FSP_ACTIVE,
SMU_FSP_PENDING,
SMU_FSP_RECOVERY
} SmuFspState;

// 故障发生
if (fault_detected && current_state == SMU_FSP_NORMAL) {
set_state(SMU_FSP_ACTIVE);
start_timer(T1);
}

// T1超时
if (timer_T1_expired && current_state == SMU_FSP_ACTIVE) {
set_state(SMU_FSP_PENDING);
notify_pmic(); // ErrorPin拉低
}

// 故障清除
if (fault_cleared && current_state == SMU_FSP_PENDING) {
set_state(SMU_FSP_RECOVERY);
start_timer(T2);
}

// 恢复成功
if (timer_T2_expired && no_new_fault && current_state == SMU_FSP_RECOVERY) {
set_state(SMU_FSP_NORMAL);
release_pmic(); // ErrorPin恢复
}

3.3 ErrorPin时序要求

3.4 PMC联动配置

// ErrorPin与PMIC联动配置
typedef struct {
uint8 enable; // 使能ErrorPin功能
uint8 active_high; // 极性：High=故障 / Low=故障
uint16 t1_delay; // T1延迟 (ms)
uint16 t2_timeout; // T2超时 (ms)
uint8 failure_counter; // 连续失败阈值
} Smu_FspConfigType;

// PMC联动场景
typedef enum {
PMC_ACTION_NONE = 0, // 无动作
PMC_ACTION_LIMP_HOME, // 进入跛行模式
PMC_ACTION_SHUTDOWN, // 关闭系统
PMC_ACTION_RESET // 触发系统复位
} Smu_PmcActionType;

四、告警组与错误分类

4.1 SMU告警组

图4：SMU告警组分类全景图

SMU将故障源划分为多个告警组 (Alarm Group)：

4.2 AG0 CPU陷阱告警详解

// CPU陷阱告警映射
typedef enum {
SMU_CPU_TRAP_ILLOPR = 0, // 非法操作码
SMU_CPU_TRAP_MUNADD = 1, // 未对齐访问
SMU_CPU_TRAP_MEM = 2, // 内存访问权限违规
SMU_CPU_TRAP_GEN = 3, // 通用陷阱
SMU_CPU_TRAP_IOPR = 4, // I/O访问违规
SMU_CPU_TRAP_CONTEXT = 5, // 上下文管理错误
SMU_CPU_TRAP_STACK = 6, // 栈溢出/下溢
SMU_CPU_TRAP_SYSCALL = 7, // 系统调用错误
} Smu_CpuTrapType;

4.3 AG1 PMU/存储告警

4.4 告警配置结构

// SMU告警配置
typedef struct {
uint8 enable; // 告警使能
uint8 sensitivity; // 触发灵敏度
uint16 debounce_time; // 去抖时间
uint8 reaction; // 响应动作
uint8 action_counter; // 动作计数器阈值
void (*callback)(uint8 ag, uint8 ai); // 回调函数
} Smu_AlarmConfigType;

// 响应动作枚举
typedef enum {
SMU_ACTION_NONE = 0, // 无动作
SMU_ACTION_NMI = 1, // 触发NMI
SMU_ACTION_RESET = 2, // 系统复位
SMU_ACTION_WDT_TRIGGER = 3, // 触发看门狗
SMU_ACTION_CALLBACK = 4, // 应用回调
SMU_ACTION_ERRPIN = 5, // ErrorPin报告
SMU_ACTION_ALL = 6, // 所有动作
} Smu_ReactionType;

五、故障响应与恢复机制

5.1 分级响应策略

SMU采用分级响应机制，根据故障严重程度执行不同动作：

┌─────────────────────────────────────────────────────────────────────┐
│ SMU 故障响应分级 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ Level 1: 警告级别 (Warning) │
│ ├─ 响应：应用回调 + 日志记录 │
│ └─ 系统：继续运行 │
│ │
│ Level 2: 错误级别 (Error) │
│ ├─ 响应：NMI中断 + 状态保存 │
│ └─ 系统：进入安全模式 │
│ │
│ Level 3: 严重级别 (Critical) │
│ ├─ 响应：系统复位 + PMIC联动 │
│ └─ 系统：重启恢复 │
│ │
│ Level 4: 致命级别 (Fatal) │
│ ├─ 响应：进入LimpHome + 禁止重启 │
│ └─ 系统：跛行回家 │
│ │
└─────────────────────────────────────────────────────────────────────┘

5.2 NMI不可屏蔽中断

NMI是SMU触发最高优先级错误处理的方式：

// NMI处理函数示例
void SMU_NMI_Handler(void)
{
// 获取触发告警信息
Smu_AlarmInfoType alarm_info;
SMU_GetCurrentAlarm(&alarm_info);

// 保存关键状态
save_critical_context();

// 记录故障日志
log_fault_event(alarm_info.alarm_group, alarm_info.alarm_index, alarm_info.timestamp);

// 根据告警类型执行对应处理
switch (alarm_info.alarm_group) {
case SMU_AG0_CPU_TRAP:
handle_cpu_trap(alarm_info);
break;
case SMU_AG1_PMU_MEM:
handle_memory_error(alarm_info);
break;
case SMU_AG2_CLOCK:
handle_clock_failure();
break;
default:
handle_generic_error(alarm_info);
break;
}

// 触发系统复位或进入安全模式
if (should_reset_system()) {
SCU_SystemReset(RESET_ORIGIN_SMU);
}
}

5.3 复位机制

// SMU触发系统复位
void SMU_TriggerSystemReset(void)
{
// 设置复位原因
SCU_RST->RSTSTAT.B.RST = RST_CAUSE_SMU;

// 触发复位
SCU->PRST0.B.CRST0 = 1;

// 等待复位生效
while(1);
}

// 复位后诊断
void POST_Reset_Diagnosis(void)
{
// 读取复位原因
uint32 rst_cause = SCU_RST->RSTSTAT.U;

if (rst_cause & RST_CAUSE_SMU) {
// SMU触发的复位 – 需要分析日志
log_reset_reason();
run_postmortem();
}
}

5.4 看门狗联动

// SMU与看门狗联动
void SMU_WDT_Coordination(void)
{
// 发生严重故障时，立即触发看门狗
if (critical_fault_detected) {
// 停止喂狗，让看门狗超时复位
disable_wdt_service();

// 或者直接触发看门狗复位
trigger_wdt_reset();
}

// 恢复过程中，延长看门狗超时时间
if (recovery_in_progress) {
set_wdt_timeout(RECOVERY_TIMEOUT);
}
}

六、配置与编程实践

6.1 MCAL接口层

SMU的MCAL层提供标准化的API接口：

// SMU MCAL 头文件
#include "Smu.h"

// 初始化
void Smu_Init(const Smu_ConfigType *ConfigPtr);

// 配置告警
void Smu_SetAlarmConfig(uint8 AlarmGroup, uint8 AlarmIndex,
const Smu_AlarmConfigType *AlarmConfig);

// 触发告警 (软件方式)
void Smu_SetAlarm(uint8 AlarmGroup, uint8 AlarmIndex);

// 清除告警
void Smu_ClearAlarm(uint8 AlarmGroup, uint8 AlarmIndex);

// 获取告警状态
Smu_AlarmStatusType Smu_GetAlarmStatus(uint8 AlarmGroup, uint8 AlarmIndex);

// 获取FSP状态
Smu_FspStateType Smu_GetFspState(void);

// 获取错误计数
uint32 Smu_GetErrorCounter(uint8 AlarmGroup, uint8 AlarmIndex);

6.2 配置XML模板

<!– SMU配置片段 (EB tresos Studio导出) –>
<SMU>
<SmuGeneral>
<SmuCoreEnable>TRUE</SmuCoreEnable>
<SmuFspEnable>TRUE</SmuFspEnable>
</SmuGeneral>

<SmuFspConfiguration>
<FspConfig>
<T1Delay>2</T1Delay> <!– 2ms –>
<T2Timeout>100</T2Timeout> <!– 100ms –>
<FailureThreshold>3</FailureThreshold>
<ErrorPinPolarity>LOW_ACTIVE</ErrorPinPolarity>
</FspConfig>
</SmuFspConfiguration>

<SmuAlarmConfiguration>
<!– AG0 CPU陷阱配置 –>
<Alarm Group="0" Index="0">
<Enable>TRUE</Enable>
<Sensitivity>EDGE</Sensitivity>
<Reaction>SMU_ACTION_NMI</Reaction>
<Callback>CPU_Trap_Callback</Callback>
</Alarm>

<!– AG1 内存错误配置 –>
<Alarm Group="1" Index="0">
<Enable>TRUE</Enable>
<Sensitivity>LEVEL</Sensitivity>
<Reaction>SMU_ACTION_RESET | SMU_ACTION_ERRPIN</Reaction>
</Alarm>

<!– AG2 时钟故障配置 –>
<Alarm Group="2" Index="0">
<Enable>TRUE</Enable>
<Reaction>SMU_ACTION_RESET</Reaction>
</Alarm>
</SmuAlarmConfiguration>
</SMU>

6.3 状态监控API

// 运行时状态监控
typedef struct {
uint32 active_alarms[8]; // 各告警组激活状态
uint32 alarm_count[8]; // 各告警组计数
uint32 fsp_state; // FSP当前状态
uint32 last_fault_time; // 上次故障时间
uint32 system_uptime; // 系统运行时间
uint8 diagnostic_status; // 自诊断状态
} Smu_RuntimeStatusType;

// 获取运行时状态
void Smu_GetRuntimeStatus(Smu_RuntimeStatusType *Status)
{
uint8 i;

for (i = 0; i < 8; i++) {
Status->active_alarms[i] = SMU->AG[i].STS.U;
Status->alarm_count[i] = SMU->AG[i].CNT.U;
}

Status->fsp_state = SMU->FSPSTS.U;
Status->system_uptime = get_system_time();
Status->diagnostic_status = SMU->DIAGSTS.U;
}

// 应用层监控任务
void SmuMonitor_Task(void)
{
Smu_RuntimeStatusType status;
Smu_GetRuntimeStatus(&status);

// 检查是否有活跃告警
for (int i = 0; i < 8; i++) {
if (status.active_alarms[i] != 0) {
// 报告告警
report_active_alarms(i, status.active_alarms[i]);
}
}

// 检查FSP状态
if (status.fsp_state != SMU_FSP_NORMAL) {
log_fsp_state_change(status.fsp_state);
}
}

6.4 诊断测试

// SMU自检 – 建议在启动时执行
void SMU_DiagnosticTest(void)
{
// 1. 检查SMU核心健康状态
if (!SMU_CORE_HEALTHY()) {
// SMU核心故障
handle_smu_core_failure();
return;
}

// 2. 注入测试告警
SMU_EnableTestMode();

// 注入并清除每个告警组
for (uint8 ag = 0; ag < 8; ag++) {
// 注入告警
SMU_InjectAlarm(ag, 0);

// 验证告警状态
if (!SMU_AlarmPending(ag, 0)) {
log_error("AG%d alarm injection failed", ag);
}

// 清除告警
SMU_ClearAlarm(ag, 0);

// 验证清除
if (SMU_AlarmPending(ag, 0)) {
log_error("AG%d alarm clear failed", ag);
}
}

SMU_DisableTestMode();

// 3. 测试ErrorPin
SMU_SetErrorPin(TRUE); // 拉高
delay_us(100);
if (ERROR_PIN_STATE != HIGH) {
log_error("ErrorPin high test failed");
}

SMU_SetErrorPin(FALSE); // 拉低
delay_us(100);
if (ERROR_PIN_STATE != LOW) {
log_error("ErrorPin low test failed");
}
}

6.5 日志记录

// SMU故障日志结构
typedef struct {
uint32 timestamp; // 绝对时间戳
uint8 alarm_group; // 告警组
uint8 alarm_index; // 告警索引
uint8 reaction_taken; // 采取的动作
uint8 cpu_context; // CPU上下文信息
uint32 additional_info; // 附加信息
} Smu_FaultLogEntry;

// 环形缓冲区存储最近N条日志
#define SMU_LOG_DEPTH 32
static Smu_FaultLogEntry fault_log[SMU_LOG_DEPTH];
static uint8 log_index = 0;

// 记录故障事件
void Smu_LogFault(uint8 alarm_group, uint8 alarm_index, uint8 reaction)
{
fault_log[log_index].timestamp = get_system_timestamp();
fault_log[log_index].alarm_group = alarm_group;
fault_log[log_index].alarm_index = alarm_index;
fault_log[log_index].reaction_taken = reaction;
fault_log[log_index].cpu_context = get_cpu_context();
fault_log[log_index].additional_info = get_additional_info();

log_index = (log_index + 1) % SMU_LOG_DEPTH;

// 持久化到Flash (可选)
save_to_flash(fault_log, sizeof(fault_log));
}

七、SMU设计最佳实践

7.1 系统启动时的SMU初始化

// SMU初始化流程
void SMU_Init_Safe(void)
{
// Step 1: 配置FSP参数
Smu_FspConfigType fspConfig = {
.enable = TRUE,
.active_high = FALSE, // 低有效
.t1_delay = 2, // 2ms
.t2_timeout = 100, // 100ms
.failure_counter = 3
};
Smu_SetFspConfig(&fspConfig);

// Step 2: 配置所有告警组
for (uint8 ag = 0; ag < 8; ag++) {
Smu_AlarmConfigType alarmCfg = {
.enable = TRUE,
.sensitivity = LEVEL,
.debounce_time = 10,
.reaction = SMU_ACTION_CALLBACK | SMU_ACTION_ERRPIN,
.callback = Alarm_Callback
};
Smu_SetAlarmConfig(ag, 0, &alarmCfg);
}

// Step 3: 启动SMU自检
SMU_DiagnosticTest();

// Step 4: 清除所有初始告警状态
SMU_ClearAllAlarms();
}

7.2 告警处理策略

// 告警回调函数
void Alarm_Callback(uint8 alarm_group, uint8 alarm_index)
{
// 记录告警信息
Smu_AlarmInfoType info;
SMU_GetAlarmInfo(alarm_group, alarm_index, &info);

// 根据告警组采取不同策略
switch (alarm_group) {
case AG0_CPU_TRAP:
// 致命错误，记录上下文并复位
dump_cpu_context();
SCU_SystemReset(RESET_ORIGIN_SMU);
break;

case AG1_PMU_MEM:
// 内存错误，根据严重程度处理
if (info.severity == SEVERITY_HIGH) {
SCU_SystemReset(RESET_ORIGIN_SMU);
} else {
log_warning("Memory error recoverable");
}
break;

case AG2_CLOCK:
// 时钟错误，立即响应
switch_to_backup_clock();
SCU_SystemReset(RESET_ORIGIN_SMU);
break;

case AG4_COMM:
// 通信错误，应用层处理
notify_comm_failure(info.index);
break;

default:
log_error("Unknown alarm group: %d", alarm_group);
break;
}
}

八、总结

8.1 SMU核心要点

8.2 设计建议

8.3 系列展望

九、技术参考

9.1 官方文档

• AURIX TC3xx User Manual Part 2 (彝起学官方)
• AN1002 – FUSA in a Nutshell (功能安全应用笔记)
• ISO 26262 Road vehicles – Functional Safety

9.2 开发资源

• EB tresos Studio – SMU配置工具
• iLLD – SMU驱动接口
• AUTOSAR BSW – SM模块

9.3 故障排查清单

┌─────────────────────────────────────────────────────────────────────┐
│ SMU 故障排查清单 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 1. ErrorPin持续拉低 │
│ → 检查AG0-AG7各告警组状态 │
│ → 确认PMC连接正确 │
│ │
│ 2. 复位后立即再次复位 │
│ → 检查启动阶段故障 │
│ → 确认SMU初始化顺序 │
│ │
│ 3. 故障清除后重复触发 │
│ → 检查硬件故障是否持续 │
│ → 增加去抖时间配置 │
│ │
│ 4. FSP状态机卡在Pending │
│ → 确认故障清除条件满足 │
│ → 检查T2超时设置 │
│ │
└─────────────────────────────────────────────────────────────────────┘

关注作者：专注汽车电子与嵌入式系统，分享AUTOSAR、AURIX、功能安全等技术干货。

本文标签：AURIX, TC3xx, SMU, 功能安全, ISO 26262, FSP, 故障管理, ASIL-D