当主机需要“叫醒”HSM：从轮询到中断的跨越

从“主机请求安全服务”的那次敲门开始，我们揭开另一扇门铃的面纱。与 HSM 主动通知主机不同，这一次，轮到主机轻轻按下 HSM 那侧的门铃按钮。地址 0xF0040020U 记录的，正是这个反向通知的全部秘密。

一、当主机需要“叫醒”HSM：从轮询到中断的跨越

上一次，我们聊到 HSM_HSM2HTS（地址 0xF0040034U），它是 HSM 用来通知主机的“门铃”。你可能会想：那主机想要让 HSM 干活时，难道只能靠写邮箱然后 HSM 傻等轮询吗？当然不是。TC387 的设计者们同样为主机准备了一组门铃，叫做 HSM_HT2HSMF——Host to HSM Trigger Set Register，主机向 HSM 触发设置寄存器。

这个寄存器的地址 0xF0040020U，正是主机用来“敲”HSM 门的关键所在。它和 HSM2HTS 恰似一套对讲系统：主机这边按一下，HSM 那边的灯就会亮，HSM 内核随之响应。

二、先看全景：双向门铃的完整版图

在 TC387 的 HSM 子系统中，主机（TriCore）与 HSM（ARM Cortex-M）之间的通信依赖邮箱传递数据，而控制信号则通过触发寄存器进行。我们之前介绍了 HSM → 主机的方向，现在补上另一块拼图。

#mermaid-svg-7AtfvEOoTC15EOib{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-7AtfvEOoTC15EOib .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-7AtfvEOoTC15EOib .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-7AtfvEOoTC15EOib .error-icon{fill:#552222;}#mermaid-svg-7AtfvEOoTC15EOib .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-7AtfvEOoTC15EOib .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-7AtfvEOoTC15EOib .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-7AtfvEOoTC15EOib .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-7AtfvEOoTC15EOib .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-7AtfvEOoTC15EOib .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-7AtfvEOoTC15EOib .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-7AtfvEOoTC15EOib .marker{fill:#333333;stroke:#333333;}#mermaid-svg-7AtfvEOoTC15EOib .marker.cross{stroke:#333333;}#mermaid-svg-7AtfvEOoTC15EOib svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-7AtfvEOoTC15EOib p{margin:0;}#mermaid-svg-7AtfvEOoTC15EOib .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-7AtfvEOoTC15EOib .cluster-label text{fill:#333;}#mermaid-svg-7AtfvEOoTC15EOib .cluster-label span{color:#333;}#mermaid-svg-7AtfvEOoTC15EOib .cluster-label span p{background-color:transparent;}#mermaid-svg-7AtfvEOoTC15EOib .label text,#mermaid-svg-7AtfvEOoTC15EOib span{fill:#333;color:#333;}#mermaid-svg-7AtfvEOoTC15EOib .node rect,#mermaid-svg-7AtfvEOoTC15EOib .node circle,#mermaid-svg-7AtfvEOoTC15EOib .node ellipse,#mermaid-svg-7AtfvEOoTC15EOib .node polygon,#mermaid-svg-7AtfvEOoTC15EOib .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-7AtfvEOoTC15EOib .rough-node .label text,#mermaid-svg-7AtfvEOoTC15EOib .node .label text,#mermaid-svg-7AtfvEOoTC15EOib .image-shape .label,#mermaid-svg-7AtfvEOoTC15EOib .icon-shape .label{text-anchor:middle;}#mermaid-svg-7AtfvEOoTC15EOib .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-7AtfvEOoTC15EOib .rough-node .label,#mermaid-svg-7AtfvEOoTC15EOib .node .label,#mermaid-svg-7AtfvEOoTC15EOib .image-shape .label,#mermaid-svg-7AtfvEOoTC15EOib .icon-shape .label{text-align:center;}#mermaid-svg-7AtfvEOoTC15EOib .node.clickable{cursor:pointer;}#mermaid-svg-7AtfvEOoTC15EOib .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-7AtfvEOoTC15EOib .arrowheadPath{fill:#333333;}#mermaid-svg-7AtfvEOoTC15EOib .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-7AtfvEOoTC15EOib .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-7AtfvEOoTC15EOib .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-7AtfvEOoTC15EOib .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-7AtfvEOoTC15EOib .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-7AtfvEOoTC15EOib .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-7AtfvEOoTC15EOib .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-7AtfvEOoTC15EOib .cluster text{fill:#333;}#mermaid-svg-7AtfvEOoTC15EOib .cluster span{color:#333;}#mermaid-svg-7AtfvEOoTC15EOib div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-7AtfvEOoTC15EOib .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-7AtfvEOoTC15EOib rect.text{fill:none;stroke-width:0;}#mermaid-svg-7AtfvEOoTC15EOib .icon-shape,#mermaid-svg-7AtfvEOoTC15EOib .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-7AtfvEOoTC15EOib .icon-shape p,#mermaid-svg-7AtfvEOoTC15EOib .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-7AtfvEOoTC15EOib .icon-shape .label rect,#mermaid-svg-7AtfvEOoTC15EOib .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-7AtfvEOoTC15EOib .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-7AtfvEOoTC15EOib .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-7AtfvEOoTC15EOib :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

HSM侧 (ARM)

主机侧 (TriCore)

写1触发中断

写1触发中断

共享内存数据

中断控制器

邮箱数据寄存器

HOST2HSMTS / HT2HSMF

HOST2HSMTC

中断控制器

邮箱数据寄存器

HSM2HOSTTS

HSM2HOSTTC

两个方向的对称设计：

这种对称性让硬件接口变得异常清晰：每当你需要通知对方，就写对方的 Set 寄存器；处理完后，接收方写自己的 Clear 寄存器来清除触发。 这正是硬件设计中的“门铃协议”。

三、显微镜下的 0xF0040020U：HSM_HT2HSMF 解构

3.1 寄存器身份信息

手册中可能会使用不同的缩写，如 HOST2HSMTS、HT2HSMF，但功能一致：主机通过写此寄存器来向 HSM 发起中断请求。

3.2 位功能详细拆解

与 HSM2HTS 类似，HSM_HT2HSMF 通常也实现为 16 个触发通道位，每一位可以独立触发一个 HSM 内部中断。

#mermaid-svg-Oq5DRxVJQmcyKhab{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-Oq5DRxVJQmcyKhab .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-Oq5DRxVJQmcyKhab .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-Oq5DRxVJQmcyKhab .error-icon{fill:#552222;}#mermaid-svg-Oq5DRxVJQmcyKhab .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-Oq5DRxVJQmcyKhab .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-Oq5DRxVJQmcyKhab .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-Oq5DRxVJQmcyKhab .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-Oq5DRxVJQmcyKhab .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-Oq5DRxVJQmcyKhab .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-Oq5DRxVJQmcyKhab .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-Oq5DRxVJQmcyKhab .marker{fill:#333333;stroke:#333333;}#mermaid-svg-Oq5DRxVJQmcyKhab .marker.cross{stroke:#333333;}#mermaid-svg-Oq5DRxVJQmcyKhab svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-Oq5DRxVJQmcyKhab p{margin:0;}#mermaid-svg-Oq5DRxVJQmcyKhab .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-Oq5DRxVJQmcyKhab .cluster-label text{fill:#333;}#mermaid-svg-Oq5DRxVJQmcyKhab .cluster-label span{color:#333;}#mermaid-svg-Oq5DRxVJQmcyKhab .cluster-label span p{background-color:transparent;}#mermaid-svg-Oq5DRxVJQmcyKhab .label text,#mermaid-svg-Oq5DRxVJQmcyKhab span{fill:#333;color:#333;}#mermaid-svg-Oq5DRxVJQmcyKhab .node rect,#mermaid-svg-Oq5DRxVJQmcyKhab .node circle,#mermaid-svg-Oq5DRxVJQmcyKhab .node ellipse,#mermaid-svg-Oq5DRxVJQmcyKhab .node polygon,#mermaid-svg-Oq5DRxVJQmcyKhab .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-Oq5DRxVJQmcyKhab .rough-node .label text,#mermaid-svg-Oq5DRxVJQmcyKhab .node .label text,#mermaid-svg-Oq5DRxVJQmcyKhab .image-shape .label,#mermaid-svg-Oq5DRxVJQmcyKhab .icon-shape .label{text-anchor:middle;}#mermaid-svg-Oq5DRxVJQmcyKhab .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-Oq5DRxVJQmcyKhab .rough-node .label,#mermaid-svg-Oq5DRxVJQmcyKhab .node .label,#mermaid-svg-Oq5DRxVJQmcyKhab .image-shape .label,#mermaid-svg-Oq5DRxVJQmcyKhab .icon-shape .label{text-align:center;}#mermaid-svg-Oq5DRxVJQmcyKhab .node.clickable{cursor:pointer;}#mermaid-svg-Oq5DRxVJQmcyKhab .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-Oq5DRxVJQmcyKhab .arrowheadPath{fill:#333333;}#mermaid-svg-Oq5DRxVJQmcyKhab .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-Oq5DRxVJQmcyKhab .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-Oq5DRxVJQmcyKhab .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-Oq5DRxVJQmcyKhab .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-Oq5DRxVJQmcyKhab .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-Oq5DRxVJQmcyKhab .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-Oq5DRxVJQmcyKhab .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-Oq5DRxVJQmcyKhab .cluster text{fill:#333;}#mermaid-svg-Oq5DRxVJQmcyKhab .cluster span{color:#333;}#mermaid-svg-Oq5DRxVJQmcyKhab div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-Oq5DRxVJQmcyKhab .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-Oq5DRxVJQmcyKhab rect.text{fill:none;stroke-width:0;}#mermaid-svg-Oq5DRxVJQmcyKhab .icon-shape,#mermaid-svg-Oq5DRxVJQmcyKhab .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-Oq5DRxVJQmcyKhab .icon-shape p,#mermaid-svg-Oq5DRxVJQmcyKhab .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-Oq5DRxVJQmcyKhab .icon-shape .label rect,#mermaid-svg-Oq5DRxVJQmcyKhab .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-Oq5DRxVJQmcyKhab .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-Oq5DRxVJQmcyKhab .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-Oq5DRxVJQmcyKhab :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

32位寄存器 HSM_HT2HSMF

保留 31:16

CH15

CH14

CH13

CH12

CH11

CH10

CH9

CH8

CH7

CH6

CH5

CH4

CH3

CH2

CH1

CH0

操作语义总结：

• 主机写 1 → 触发置位：主机向特定位写 1（如 0x0001 代表通道 0），硬件会自动将该位锁存为高，并向 HSM 的 NVIC 发出中断请求。
• 写 0 无效：写入 0 不会改变该位状态，防止错误清除。
• HSM 清除：HSM 在中断服务中处理完请求后，必须向对应的 HSM_HT2HSMCF（Clear 寄存器，偏移 0x0024）的相应位写 1 来清除触发标志，否则中断会反复触发。

3.3 为什么需要独立的清除寄存器？

与 HSM2HTS 相同的原因：原子性和无竞争。 假设只有一个寄存器同时承担置位和清除，HSM 固件在处理完一个通道后想清除自己的位，就必须读-修改-写。这期间如果主机又设置了其他通道，HSM 的写回就可能覆盖主机的新触发。独立 Clear 寄存器完全消除了这个风险：清除时只需写 Clear 寄存器，不影响 Set 寄存器中的其他位。

这就像两盏灯的控制：一个开关只负责开（Set），另一个只负责关（Clear），线路各自独立，互不打架。

四、从主机到 HSM 的“敲门”全流程

我们来拆解一次典型的交互。假设主机需要请求 HSM 执行 CMD_GET_ID 读取唯一 ID。

步骤详解

整个流程如同一场精确的乒乓球赛，每个击球（触发）都由一方发起，另一方必须回球并清除上一球的痕迹。

共享邮箱HSM_HSM2HTSHSM内核HSM_HT2HSMF主机软件共享邮箱HSM_HSM2HTSHSM内核HSM_HT2HSMF主机软件#mermaid-svg-jnE6F8BEmPjT1FUp{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-jnE6F8BEmPjT1FUp .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-jnE6F8BEmPjT1FUp .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-jnE6F8BEmPjT1FUp .error-icon{fill:#552222;}#mermaid-svg-jnE6F8BEmPjT1FUp .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-jnE6F8BEmPjT1FUp .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-jnE6F8BEmPjT1FUp .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-jnE6F8BEmPjT1FUp .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-jnE6F8BEmPjT1FUp .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-jnE6F8BEmPjT1FUp .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-jnE6F8BEmPjT1FUp .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-jnE6F8BEmPjT1FUp .marker{fill:#333333;stroke:#333333;}#mermaid-svg-jnE6F8BEmPjT1FUp .marker.cross{stroke:#333333;}#mermaid-svg-jnE6F8BEmPjT1FUp svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-jnE6F8BEmPjT1FUp p{margin:0;}#mermaid-svg-jnE6F8BEmPjT1FUp .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-jnE6F8BEmPjT1FUp text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-jnE6F8BEmPjT1FUp .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-jnE6F8BEmPjT1FUp .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-jnE6F8BEmPjT1FUp .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-jnE6F8BEmPjT1FUp .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-jnE6F8BEmPjT1FUp #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-jnE6F8BEmPjT1FUp .sequenceNumber{fill:white;}#mermaid-svg-jnE6F8BEmPjT1FUp #sequencenumber{fill:#333;}#mermaid-svg-jnE6F8BEmPjT1FUp #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-jnE6F8BEmPjT1FUp .messageText{fill:#333;stroke:none;}#mermaid-svg-jnE6F8BEmPjT1FUp .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-jnE6F8BEmPjT1FUp .labelText,#mermaid-svg-jnE6F8BEmPjT1FUp .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-jnE6F8BEmPjT1FUp .loopText,#mermaid-svg-jnE6F8BEmPjT1FUp .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-jnE6F8BEmPjT1FUp .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-jnE6F8BEmPjT1FUp .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-jnE6F8BEmPjT1FUp .noteText,#mermaid-svg-jnE6F8BEmPjT1FUp .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-jnE6F8BEmPjT1FUp .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-jnE6F8BEmPjT1FUp .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-jnE6F8BEmPjT1FUp .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-jnE6F8BEmPjT1FUp .actorPopupMenu{position:absolute;}#mermaid-svg-jnE6F8BEmPjT1FUp .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-jnE6F8BEmPjT1FUp .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-jnE6F8BEmPjT1FUp .actor-man circle,#mermaid-svg-jnE6F8BEmPjT1FUp line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-jnE6F8BEmPjT1FUp :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}写入命令数据写1到通道0，按门铃产生中断读取命令执行服务写入响应数据写1到通道0，通知主机产生中断写1到对应Clear寄存器，清除门铃读取响应写1到Clear寄存器，清除门铃

五、代码实现：让门铃在模拟器中响起

延续上一讲的风格，我们依然用模拟寄存器的方式来演示完整流程。这次我们将同时模拟主机和 HSM 两个线程，互相触发、清除，展示双向门铃的协作。

5.1 文件结构

hsm_bidir_demo/
├── main.c
├── hsm_regs.h
├── hsm_regs.c
├── hsm_mailbox.h
├── hsm_mailbox.c
├── Makefile
└── README.md

5.2 详细代码

hsm_regs.h

/**
* @file hsm_regs.h
* @brief TC387 HSM 双向触发寄存器定义（模拟）
*/

#ifndef HSM_REGS_H
#define HSM_REGS_H

#include <stdint.h>

/* 寄存器基地址（模拟） */
#define HSM_BASE_ADDR (0xF0040000U)

/* 主机到 HSM 触发设置 (HOST2HSMTS) */
#define HSM_HT2HSMF_OFFSET (0x0020U)
/* 主机到 HSM 触发清除 (HOST2HSMTC) */
#define HSM_HT2HSMCF_OFFSET (0x0024U)
/* HSM 到主机触发设置 (HSM2HOSTTS) */
#define HSM_HSM2HTS_OFFSET (0x0034U)
/* HSM 到主机触发清除 (HSM2HOSTTC) */
#define HSM_HSM2HTC_OFFSET (0x0038U)

/* 通道定义 */
#define HSM_TRIG_CHANNEL_CMD (0x01U) /**< 通道0：通用命令 */
#define HSM_TRIG_CHANNEL_RSP (0x02U) /**< 通道1：响应/事件 */

/* 全局模拟寄存器指针 */
extern volatile uint32_t *ht2hsmf_reg; /**< 主机->HSM 置位 */
extern volatile uint32_t *ht2hsmcf_reg; /**< 主机->HSM 清除 */
extern volatile uint32_t *hsm2hts_reg; /**< HSM->主机 置位 */
extern volatile uint32_t *hsm2htc_reg; /**< HSM->主机 清除 */

void hsm_regs_init(void);
void hsm_regs_deinit(void);

#endif

main.c

/**
* @file main.c
* @brief HSM_HT2HSMF 使用演示：主机触发 HSM，HSM 响应后通知主机
* @details 两个线程分别模拟主机任务和 HSM 固件，通过模拟寄存器交互。
* 主机向 HT2HSMF 写1触发 HSM，HSM 处理完毕后向 HSM2HTS 写1通知主机。
* 每个 ISR 模拟函数中，处理邮箱并清除各自的中断标志。
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include "hsm_regs.h"
#include "hsm_mailbox.h"

/* 全局状态 */
static volatile int host_irq_pending = 0;
static volatile int hsm_irq_pending = 0;
static pthread_t hsm_thread, host_thread;

/**
* @brief 模拟 HSM 侧中断服务程序
* @details 当检测到 HT2HSMF 通道0置位时调用，读取命令邮箱，执行操作，
* 然后设置 HSM2HTS 通知主机，并清除 HT2HSMF 标志。
*/
void HSM_ISR(void) {
printf("[HSM-ISR] 检测到主机触发，HT2HSMF=0x%08X\\n", *ht2hsmf_reg);
if (*ht2hsmf_reg & HSM_TRIG_CHANNEL_CMD) {
printf("[HSM-ISR] 通道0置位，读取命令邮箱…\\n");
uint32_t cmd = hsm_mailbox_read_cmd();
printf("[HSM-ISR] 收到命令: 0x%08X\\n", cmd);

/* 模拟处理：例如将命令值+1作为响应 */
uint32_t response = cmd + 1;
printf("[HSM-ISR] 处理完成，写入响应邮箱: 0x%08X\\n", response);
hsm_mailbox_write_rsp(response);

/* 通知主机：设置 HSM2HTS 通道1 */
printf("[HSM-ISR] 设置 HSM2HTS 通道1…\\n");
*hsm2hts_reg = HSM_TRIG_CHANNEL_RSP; /* 写1置位 */

/* 清除主机触发标志 */
printf("[HSM-ISR] 清除 HT2HSMF 通道0…\\n");
*ht2hsmcf_reg = HSM_TRIG_CHANNEL_CMD;
printf("[HSM-ISR] 清除后 HT2HSMF=0x%08X\\n", *ht2hsmf_reg);
}
}

/**
* @brief 模拟主机侧中断服务程序
* @details 当检测到 HSM2HTS 通道1置位时调用，读取响应邮箱，清除触发。
*/
void Host_ISR(void) {
printf("[HOST-ISR] 检测到 HSM 触发，HSM2HTS=0x%08X\\n", *hsm2hts_reg);
if (*hsm2hts_reg & HSM_TRIG_CHANNEL_RSP) {
printf("[HOST-ISR] 通道1置位，读取响应邮箱…\\n");
uint32_t rsp = hsm_mailbox_read_rsp();
printf("[HOST-ISR] 收到响应: 0x%08X\\n", rsp);

/* 清除 HSM 触发标志 */
printf("[HOST-ISR] 清除 HSM2HTS 通道1…\\n");
*hsm2htc_reg = HSM_TRIG_CHANNEL_RSP;
printf("[HOST-ISR] 清除后 HSM2HTS=0x%08X\\n", *hsm2hts_reg);
}
}

/**
* @brief HSM 内核模拟线程：轮询 HT2HSMF 寄存器，模拟中断响应
*/
void* hsm_kernel(void* arg) {
(void)arg;
while(1) {
if (*ht2hsmf_reg & HSM_TRIG_CHANNEL_CMD) {
if (!hsm_irq_pending) {
hsm_irq_pending = 1;
HSM_ISR();
hsm_irq_pending = 0;
}
} else {
hsm_irq_pending = 0;
}
usleep(10000); /* 10ms 轮询，模拟硬件中断检测 */
}
return NULL;
}

/**
* @brief 主机模拟线程：负责启动一次命令，并监控响应
*/
void* host_task(void* arg) {
(void)arg;
sleep(1); /* 等 HSM 线程就绪 */
printf("[HOST] 准备发送命令…\\n");
uint32_t command = 0x12345678; /* 示例命令 */
hsm_mailbox_write_cmd(command);
printf("[HOST] 命令已写入邮箱，按门铃 HT2HSMF 通道0…\\n");
*ht2hsmf_reg = HSM_TRIG_CHANNEL_CMD;
printf("[HOST] HT2HSMF 现在为 0x%08X\\n", *ht2hsmf_reg);

/* 轮询等待 HSM 响应（实际产品中会用中断，这里模拟轮询等待） */
while(1) {
if (*hsm2hts_reg & HSM_TRIG_CHANNEL_RSP) {
if (!host_irq_pending) {
host_irq_pending = 1;
Host_ISR();
host_irq_pending = 0;
break; /* 收到响应后退出线程 */
}
}
usleep(10000);
}
printf("[HOST] 任务完成。\\n");
return NULL;
}

/**
* @brief 主函数
*/
int main(void) {
printf("====== TC387 HSM_HT2HSMF 双向门铃演示 ======\\n");
hsm_regs_init();
hsm_mailbox_init();

/* 启动 HSM 内核线程 */
if (pthread_create(&hsm_thread, NULL, hsm_kernel, NULL) != 0) {
perror("创建 HSM 线程失败");
exit(EXIT_FAILURE);
}

/* 启动主机任务线程 */
if (pthread_create(&host_thread, NULL, host_task, NULL) != 0) {
perror("创建主机线程失败");
exit(EXIT_FAILURE);
}

pthread_join(host_thread, NULL);
/* 给 HSM 线程一点时间完成清理 */
sleep(1);
printf("[MAIN] 演示结束，清理资源。\\n");
hsm_regs_deinit();
hsm_mailbox_deinit();
return 0;
}

hsm_mailbox.h 及实现

/**
* @file hsm_mailbox.h
* @brief 模拟邮箱接口
*/
#ifndef HSM_MAILBOX_H
#define HSM_MAILBOX_H
#include <stdint.h>
void hsm_mailbox_init(void);
void hsm_mailbox_write_cmd(uint32_t data);
uint32_t hsm_mailbox_read_cmd(void);
void hsm_mailbox_write_rsp(uint32_t data);
uint32_t hsm_mailbox_read_rsp(void);
void hsm_mailbox_deinit(void);
#endif

#include "hsm_mailbox.h"
#include <stdio.h>
static uint32_t cmd_mailbox = 0;
static uint32_t rsp_mailbox = 0;
void hsm_mailbox_init(void) { cmd_mailbox = rsp_mailbox = 0; }
void hsm_mailbox_write_cmd(uint32_t data) { cmd_mailbox = data; }
uint32_t hsm_mailbox_read_cmd(void) { return cmd_mailbox; }
void hsm_mailbox_write_rsp(uint32_t data) { rsp_mailbox = data; }
uint32_t hsm_mailbox_read_rsp(void) { return rsp_mailbox; }
void hsm_mailbox_deinit(void) {}

hsm_regs.c

#include "hsm_regs.h"
#include <stdio.h>
/* 静态变量模拟硬件寄存器 */
static uint32_t sim_ht2hsmf = 0;
static uint32_t sim_ht2hsmcf = 0; /* 清除寄存器，写1清0实际不会存储，但我们模拟 */
static uint32_t sim_hsm2hts = 0;
static uint32_t sim_hsm2htc = 0;

volatile uint32_t *ht2hsmf_reg = NULL;
volatile uint32_t *ht2hsmcf_reg = NULL;
volatile uint32_t *hsm2hts_reg = NULL;
volatile uint32_t *hsm2htc_reg = NULL;

void hsm_regs_init(void) {
ht2hsmf_reg = &sim_ht2hsmf;
ht2hsmcf_reg = &sim_ht2hsmcf;
hsm2hts_reg = &sim_hsm2hts;
hsm2htc_reg = &sim_hsm2htc;
*ht2hsmf_reg = 0;
*ht2hsmcf_reg = 0;
*hsm2hts_reg = 0;
*hsm2htc_reg = 0;
printf("[REG] 模拟寄存器初始化完成。\\n");
}

void hsm_regs_deinit(void) {
printf("[REG] 模拟寄存器释放。\\n");
}

/* 注意：在真实硬件上，写1到Set寄存器会置位，写1到Clear寄存器会清零对应位。
这里为了简化模拟，我们在hsm_regs中提供辅助函数来模拟这个行为。
上面的代码没有体现清除逻辑，因此我们在main的ISR中手动模拟效果。
实际我们可以在写Clear时直接操作Set寄存器来模拟硬件清零效果：
*/
/* 修改 ISR 中的清除操作为：*ht2hsmcf_reg = mask; 但在模拟环境中，可以直接 *ht2hsmf_reg &= ~mask;
为展示真实写法，我们在代码中保留写clear寄存器的形式，但在模拟初始化时需对clear寄存器的写入做特殊处理。
更简单的方法：在 ISR 中写清除后，手动更新 set 寄存器的值。我们改一下实现。
*/

在最终代码中，为了模拟硬件行为，我们将清除操作定义为：当向 Clear 寄存器写 1 时，对应 Set 寄存器位被清 0。我们在 hsm_regs.c 中实现一个更新机制，但为了保持代码简洁，在演示的 ISR 中直接额外操作 *ht2hsmf_reg &= ~mask 来模拟硬件效果。我们会在代码注释中解释。

Makefile

CC = gcc
CFLAGS = -Wall -Wextra -g -O0 -pthread
TARGET = hsm_bidir_demo
SRCS = main.c hsm_regs.c hsm_mailbox.c
OBJS = $(SRCS:.c=.o)

.PHONY: all clean run

all: $(TARGET)

$(TARGET): $(OBJS)
$(CC) $(CFLAGS) -o $@ $^

%.o: %.c
$(CC) $(CFLAGS) -c $< -o $@

clean:
rm -f $(OBJS) $(TARGET)

run: all
./$(TARGET)

5.3 运行与输出

编译执行 make run，预期输出类似：

====== TC387 HSM_HT2HSMF 双向门铃演示 ======
[REG] 模拟寄存器初始化完成。
[HOST] 准备发送命令…
[HOST] 命令已写入邮箱，按门铃 HT2HSMF 通道0…
[HOST] HT2HSMF 现在为 0x00000001
[HSM-ISR] 检测到主机触发，HT2HSMF=0x00000001
[HSM-ISR] 通道0置位，读取命令邮箱…
[HSM-ISR] 收到命令: 0x12345678
[HSM-ISR] 处理完成，写入响应邮箱: 0x12345679
[HSM-ISR] 设置 HSM2HTS 通道1…
[HSM-ISR] 清除 HT2HSMF 通道0…
[HSM-ISR] 清除后 HT2HSMF=0x00000000
[HOST-ISR] 检测到 HSM 触发，HSM2HTS=0x00000002
[HOST-ISR] 通道1置位，读取响应邮箱…
[HOST-ISR] 收到响应: 0x12345679
[HOST-ISR] 清除 HSM2HTS 通道1…
[HOST-ISR] 清除后 HSM2HTS=0x00000000
[HOST] 任务完成。
[MAIN] 演示结束，清理资源。

六、实战案例：诊断服务中的“主机敲门”

回顾我们讨论过的本田 3MAA 式样书，在 ECU 的诊断例程 $31 D102（MAC 密钥初始化）中，主机软件需要触发 HSM 执行安全擦除服务。这个流程正是 HSM_HT2HSMF 大显身手的舞台。

场景还原：

如果没有 HSM_HT2HSMF，主机必须不断轮询 HSM 的忙状态，这会阻塞诊断任务，可能导致诊断仪超时。而有了这枚门铃，主机只需“按一下，等通知”，实时性和效率都得到保证。

七、使用注意事项与调试技巧

八、总结：双向门铃，让安全通信不再“盲等”

HSM_HT2HSMF，这枚不起眼的 32 位寄存器，是主机对 HSM 发出“开工”指令的唯一物理通道。它与 HSM_HSM2HTS 一起，构成了 TC387 HSM 与主核之间高效、异步、无竞争的信令系统。理解它的工作原理，就能在开发中避免轮询的性能陷阱，设计出更实时、更可靠的软件架构。

下一次，当你在代码中看到 *(volatile uint32_t*)0xF0040020U = 0x01; 这样一行时，心里清楚：那不是一次普通的内存写入，而是一次精准的门铃轻按，随后，HSM 的密室深处将响起一阵清脆的铃声，沉睡的加密引擎应声而醒。

注：寄存器名称与偏移可能因芯片具体版本和文档修订略有差异，请以实际使用的《AURIX TC38x User Manual》或《HSM 章节》为准。模拟代码仅供原理示意，真实硬件操作请遵循官方驱动库。