复位生效需要被处理的场景

复位信号不只需要在释放的时候需要被处理,在生效的时候某些情况下也需要被处理.

关键信息整理：

• 复位生效到寄存器实际复位完成之间存在延迟（即使是纳秒级），或者复位信号本身存在毛刺，就可能在这些短暂瞬间输出非安全值。

场景1：复位毛刺导致误触发（最高发风险）

问题本质

异步复位信号对毛刺敏感，短脉冲干扰会被误判为有效复位，导致系统运行时意外重启。

理想复位信号：   ______/‾‾‾‾‾‾‾\___________  
实际受干扰信号： ______/‾‾\__/‾‾\______/‾‾‾‾‾‾\___  // 毛刺触发复位！
               ↑    ↑    ↑         ↑
             毛刺1 毛刺2 有效复位  毛刺3

不处理的后果

• 案例：工业电机控制器
  电刷火花产生电磁脉冲，触发复位毛刺。
  现象：电机运行时突然停止（复位生效） → 0.5秒后自动恢复 → 生产流水线频繁中断，每日损失数十万元。

解决方案：添加复位毛刺滤波器

        异步复位输入 → [毛刺滤波器] → 净化复位信号 → 后续电路
         (脉宽 < T_filter的脉冲被滤除)

实现方案：        

module reset_filter (
    input  clk,
    input  async_rst_n,  // 低有效异步复位输入
    output logic filtered_rst_n  // 过滤后的复位输出
);
  
// 状态机状态定义
typedef enum logic [1:0] {
    IDLE       = 2'b11,  // 复位无效状态
    COUNTING   = 2'b01,  // 低电平计数中
    RESET_ACT  = 2'b00   // 复位有效状态
} state_t;

state_t current_state, next_state;
logic [1:0] counter;  // 低电平持续时间计数器

// 状态转移逻辑
always_ff @(posedge clk, negedge async_rst_n) begin
    if (!async_rst_n) begin           // 异步复位生效
        current_state <= COUNTING;    // 立即进入计数状态
        counter <= 2'b00;             // 清零计数器
    end else begin                    // 正常时钟驱动
        current_state <= next_state;
        
        // 计数逻辑：在COUNTING状态下每个周期+1
        if (current_state == COUNTING) 
            counter <= counter + 1;
        else
            counter <= 2'b00;         // 其他状态清零计数器
    end
end

// 状态转移条件
always_comb begin
    case (current_state)
        IDLE:
            next_state = async_rst_n ? IDLE : COUNTING;
            
        COUNTING:
            // 计数满3个周期 OR 复位提前释放
            next_state = (counter == 2'b10) ? RESET_ACT : 
                         (async_rst_n) ? IDLE : COUNTING;
            
        RESET_ACT:
            next_state = async_rst_n ? IDLE : RESET_ACT;
            
        default:
            next_state = IDLE;
    endcase
end

// 输出逻辑
assign filtered_rst_n = (current_state == RESET_ACT) ? 1'b0 : 1'b1;

endmodule

时钟周期: 1   2   3   4   5   6   7   8   9   10  11  12
---------------------------------------------------------
clk:     _/‾\_/‾\_/‾\_/‾\_/‾\_/‾\_/‾\_/‾\_/‾\_/‾\_/‾\_
async_rst_n: 
         ‾‾‾‾‾\________/‾‾‾\___________________________  // 毛刺1 (周期4)
         ‾‾‾‾‾‾‾‾‾\___________________/‾‾‾‾‾‾‾‾‾‾‾‾‾  // 有效复位 (周期6-8)
         ‾‾‾‾‾‾‾‾‾‾‾‾‾‾\______/‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾  // 毛刺2 (周期10)

filtered_rst_n:
         ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\___________/‾‾‾‾‾‾‾‾‾  // 仅响应有效复位

为何必须处理复位生效？

• 直接干预生效判定：短脉冲毛刺不再触发复位，只有持续低电平 > 3个时钟周期才判定为有效复位。

• 牺牲响应速度换取可靠性：真实复位生效被延迟3周期，但避免灾难性误触发。

场景2：超大规模芯片复位偏移（Reset Skew）

问题本质

在5nm工艺的600mm²芯片中，复位信号到达不同区域的延迟差异极大：

        复位源 → 寄存器A (近端)：延迟 0.1ns  
        → 寄存器B (远端)：延迟 2.3ns  // 跨芯片传播延迟

不处理的后果

• 案例：AI加速芯片
  计算单元A (近复位源) 比存储单元B (远端) 早2ns进入复位状态。
  现象：
  A单元复位生效后立即清零状态信号 → B单元仍在运行，采样到A的零信号 → 误判为计算完成 → 写入错误结果到DDR，导致神经网络推理崩溃。

解决方案：复位树综合 (Reset Tree Synthesis)

        复位源 → [Buffer Level 1] → [Buffer Level 2] → ... → [Buffer Level N]  
               ├─► Region A (总延迟 2.0ns)  
               ├─► Region B (总延迟 2.0ns)  // 人工平衡延迟  
               └─► Region C (总延迟 2.0ns)

为何必须处理复位生效？

• 物理对齐生效时刻：通过插入缓冲器，使复位信号到达所有寄存器的物理时间一致（误差<50ps）。

• 不改变逻辑行为，只修正时序：复位仍是异步生效，但全芯片同步生效。

场景3：混合复位源优先级冲突

问题本质

        系统存在多个复位源，且优先级不同：

- 硬复位 (硬件按钮)：优先级最高，需立即生效  
- 看门狗复位：优先级中，需立即生效  
- 软件复位：优先级低，可同步生效

不处理的后果

• 案例：汽车仪表盘SoC
  软件复位与看门狗复位同时触发：
  现象：
  软件复位先释放 → 屏幕闪烁 → 看门狗复位0.1ms后生效 → 屏幕再次黑屏 → 用户感知“二次复位”，怀疑系统故障。

解决方案：复位仲裁器

module reset_arbiter (
    input  clk,
    input  hw_rst_n,    // 硬件复位 (高优先级)
    input  wdog_rst_n,  // 看门狗复位
    input  sw_rst_n,    // 软件复位 (低优先级)
    output logic sys_rst_n
);

// 高优先级复位：立即异步生效
always_ff @(negedge hw_rst_n, negedge wdog_rst_n) begin 
    if (!hw_rst_n || !wdog_rst_n) begin
        sys_rst_n <= 0;  // 硬件或看门狗复位立即生效
    end
end

// 低优先级复位：同步生效
always_ff @(posedge clk) begin 
    if (!sw_rst_n) begin
        sys_rst_n <= 0;  // 软件复位等到时钟沿才生效
    end else if (hw_rst_n && wdog_rst_n) {
        sys_rst_n <= 1;  // 同步释放
    }
end
endmodule

为何必须处理复位生效？

• 差异化生效策略：

  • 高优先级复位：保持异步立即生效

  • 低优先级复位：改为同步生效（等待时钟沿）

• 避免复位冲突：防止低优先级复位干扰高优先级复位的紧急响应。

终极总结：复位生效（Assertion）需处理的三大场景

复位生效处理的本质

所有处理均围绕一个核心：在保持异步复位“快速响应”优势的前提下，解决其物理缺陷（噪声敏感/延迟偏差）或逻辑冲突（多源竞争）。
绝不改变“立即强制寄存器复位”的行为，只修正何时判定复位生效或如何传递复位信号。

与复位释放处理的根本区别

关键场景下复位生效处理的必要性及举例

场景一：多时钟域交互（复位作为协调信号）

• 必要性： 当不同时钟域的两个模块需要协同复位，或者一个模块的复位会影响另一个时钟域模块的状态时，复位生效的相对时序至关重要。如果不处理（即让复位在各自时钟域随意生效），可能导致状态不一致、死锁或违反握手协议。

• 不处理的后果： 状态不一致、死锁、协议违规。

• 举例：

  • FIFO的写指针和读指针在不同时钟域： 假设一个异步FIFO，写时钟域 (wclk) 和读时钟域 (rclk) 独立。当系统需要复位FIFO时，复位信号 (rst_n) 需要同时（或在非常接近的时间内）作用于写指针逻辑和读指针逻辑。

    • 不处理： 如果 rst_n 在 wclk 域生效，清零了写指针，但在 rclk 域尚未生效（或延迟很久才生效），读指针可能还在旧值。此时FIFO的空满状态判断逻辑（通常是基于指针比较）会瞬间计算出错误的结果（比如认为非空，但写指针已归零）。这可能导致读逻辑试图从已复位的（无效的）FIFO位置读取数据（因为非空，读逻辑可能继续读），或者状态标志错误触发后续逻辑故障。

处理前的RTL：

module FIFO_Bad (
  input wire wclk,        // 写时钟
  input wire rclk,        // 读时钟
  input wire rst_n        // 异步复位
);
  
  // 写指针（写时钟域）
  reg [7:0] wptr;
  always @(posedge wclk or negedge rst_n) begin
    if (!rst_n) wptr <= 0;  // 复位立即清零
    else wptr <= wptr + 1;   // 正常操作
  end
  
  // 读指针（读时钟域）
  reg [7:0] rptr;
  always @(posedge rclk or negedge rst_n) begin
    if (!rst_n) rptr <= 0;  // 复位立即清零
    else rptr <= rptr + 1;   // 正常操作
  end
  
  // 空标志判断（跨时钟域比较）
  wire empty = (wptr == rptr); // 当指针相等时认为空
  
endmodule

• 处理： 虽然复位生效本身是异步的，但需要确保 rst_n 到达写时钟域和读时钟域逻辑的延迟尽可能小且确定（通过精心布局布线或使用低偏移的复位分布树）。有时甚至会使用一个公共的异步复位源，然后分别在各自时钟域做同步释放（注意，这是针对释放的），但生效的源头时刻是同时的。这里对生效的“处理”体现在确保复位信号在物理设计上能几乎同时到达关键跨时钟域模块。

处理后的RTL

module FIFO_Good (
  input wire wclk,
  input wire rclk,
  input wire rst_n_global  // 全局复位源
);
  
  // 低偏斜复位分布树（后端保证）
  wire rst_n_w, rst_n_r;
  reset_distribution_tree u_tree (
    .rst_in(rst_n_global),
    .rst_out1(rst_n_w),    // 到写时钟域
    .rst_out2(rst_n_r)     // 到读时钟域
  );
  
  // 写指针（复位路径延迟平衡）
  reg [7:0] wptr;
  always @(posedge wclk or negedge rst_n_w) begin
    if (!rst_n_w) wptr <= 0;
    else wptr <= wptr + 1;
  end
  
  // 读指针（复位路径延迟平衡）
  reg [7:0] rptr;
  always @(posedge rclk or negedge rst_n_r) begin
    if (!rst_n_r) rptr <= 0;
    else rptr <= rptr + 1;
  end
  
  // 空标志判断
  wire empty = (wptr == rptr);
  
endmodule

• 主从设备通信（如 SPI, I2C 从设备）： 主设备在时钟域A，从设备在时钟域B。主设备发起复位。

  • 不处理： 如果主设备发出的复位信号异步生效，立刻拉低从设备的复位引脚，而此时从设备内部状态机可能正处于一次传输的中间状态（例如，正在驱动数据线），复位生效会强制其进入初始状态，导致其立即停止驱动数据线。如果主设备时钟 (sclk) 还在运行，主设备可能会在下一个时钟沿采样到一个“浮空”或未定义的数据线状态（本应是从设备驱动的有效数据），导致主设备读取错误数据，甚至破坏整个通信帧。

处理前RTL：

module SPI_Slave_Bad (
  input wire clk,         // 系统时钟
  input wire rst_n,       // 异步复位（低有效）
  input wire ssel,        // 片选信号（低有效）
  input wire sck,         // SPI 时钟
  input wire mosi,        // 主设备输出
  output reg miso         // 从设备输出
);

  // 内部状态寄存器
  reg [7:0] shift_reg;
  reg [2:0] bit_count;
  
  // 异步复位逻辑 - 问题点：仅复位内部状态
  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      // 复位内部状态
      shift_reg <= 8'h00;
      bit_count <= 3'b0;
      miso <= 1'b0;      // 错误：直接驱动固定电平
    end else if (!ssel) begin
      // 正常 SPI 操作
      shift_reg <= {shift_reg[6:0], mosi};
      bit_count <= bit_count + 1;
      miso <= shift_reg[7]; // 输出最高位
    end else begin
      // 片选无效时输出 0
      miso <= 1'b0;      // 错误：仍在驱动总线! 这是在驱动总线为低电平，如果此时需要slave

                                  //释放总线，应该是miso <= 1'bz。
    end
  end

endmodule

• 处理： 主设备需要在发起复位前，先确保通信处于一个安全点（如总线空闲状态），然后再拉低复位信号。或者，从设备设计需要在复位生效的瞬间，确保其输出驱动器被安全地置于高阻态（Hi-Z），而不是在复位生效瞬间产生一个毛刺或驱动冲突。这需要对复位生效时接口IO缓冲器的行为进行控制设计。

处理后的RTL：

module SPI_Slave_Good (
  input wire clk,         // 系统时钟
  input wire rst_n,       // 异步复位（低有效）
  input wire ssel,        // 片选信号（低有效）
  input wire sck,         // SPI 时钟
  input wire mosi,        // 主设备输出
  output wire miso        // 从设备输出（三态）
);

  // 关键信号声明
  reg force_high_z;       // 复位生效标志
  reg [7:0] shift_reg;    // 移位寄存器
  reg [2:0] bit_count;    // 位计数器
  reg normal_miso;        // 正常输出值
  reg normal_miso_en;     // 正常输出使能
  
  // =============================================
  // 核心改进：复位生效的异步即时处理
  // =============================================
  
  // 1. 复位生效的异步响应（不依赖时钟！）
  always @(negedge rst_n) begin
    force_high_z <= 1'b1;  // 复位生效立即标记
  end
  
  // 2. 复位释放的同步处理
  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      force_high_z <= 1'b1; // 保持高阻标志
    end else begin
      force_high_z <= 1'b0; // 复位释放后清除标志
    end
  end

  // =============================================
  // 正常通信逻辑
  // =============================================
  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      // 复位内部状态
      shift_reg <= 8'h00;
      bit_count <= 3'b0;
      normal_miso <= 1'b0;
      normal_miso_en <= 1'b0; // 禁用正常输出
    end else begin
      if (!ssel) begin
        // SPI 传输中
        shift_reg <= {shift_reg[6:0], mosi};
        bit_count <= bit_count + 1;
        normal_miso <= shift_reg[7]; // 准备输出数据
        normal_miso_en <= 1'b1;     // 使能输出
      end else begin
        // 片选无效时禁用输出
        normal_miso_en <= 1'b0;
      end
    end
  end

  // =============================================
  // 输出仲裁逻辑（优先级控制）
  // =============================================
  // 三态输出实现
  assign miso = (force_high_z) ? 1'bZ :       // 最高优先级：复位生效时强制高阻
                (normal_miso_en) ? normal_miso : 1'bZ; // 次优先级：正常通信输出
  
endmodule

三态输出优先级控制

• 层级 1：force_high_z=1 → 输出 Z（最高优先级）

• 层级 2：normal_miso_en=1 → 输出数据

• 层级 3：默认输出 Z

场景二：复位期间的状态机安全

• 必要性： 复杂状态机在复位生效瞬间可能处于任意状态。如果复位生效逻辑设计不当，可能无法将所有状态寄存器干净地复位到定义的初始状态，或者在复位过程中产生短暂的非法状态组合，这些组合可能在下游逻辑中引起冒险或毛刺。

• 不处理的后果： 复位状态残留、短暂非法状态、毛刺。

• 举例：

  • 带复杂编码的状态机： 一个状态机使用One-Hot编码（如4个状态用 0001, 0010, 0100, 1000）。理想复位状态是 0001。

    • 不处理（简单异步复位连接）： 在复位信号 (rst_n) 生效的瞬间，所有状态寄存器被异步清零。如果各触发器的复位路径延迟有微小差异，可能出现短暂的中间状态，如 0000（所有位都清零了，但这是非法状态！）或者 0011（部分清零）。如果下游组合逻辑检测到 0000 或 0011 并立即产生动作（例如，一个输出在 0000 时有效），就会在复位生效过程中产生一个毛刺脉冲。这个毛刺可能导致意想不到的操作（如错误地使能一个模块）。

    • 处理：

      • 方案一（推荐）： 使用同步复位。在目标时钟域内，当检测到复位请求有效时，在下一个时钟边沿将状态机同步复位到初始状态 (0001)。这完全避免了复位生效瞬间的冒险问题。

      • 方案二（异步复位）： 设计一个复位状态编码器。不使用简单的寄存器异步清零端，而是设计一个多路复用器（MUX）。在复位有效时 (rst_n = 0)，该MUX强制选择初始状态向量 (0001) 输出到状态寄存器组的D输入端；在复位无效时 (rst_n = 1)，MUX选择次态逻辑的输出。状态寄存器使用带异步置位/复位端的触发器，但只将它们用于芯片上电时的初始复位（Power-On Reset）。对于功能复位，则通过上述同步的MUX方案实现。这确保了即使在异步复位生效时，状态寄存器的输入也是稳定的合法初始状态，消除了复位毛刺和非法状态。这是对复位生效方式的一种“处理”。

处理前RTL：

module FSM_Bad (
  input wire clk,
  input wire rst_n,
  output reg alarm  // 报警信号
);
  
  // One-Hot状态编码
  parameter IDLE  = 3'b001;
  parameter WORK  = 3'b010;
  parameter ERROR = 3'b100;
  
  reg [2:0] state;
  
  // 异步复位直接清零
  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) state <= 0;  // 复位后状态=000（非法！）
    else begin
      case(state)
        IDLE:  state <= WORK;
        WORK:  state <= ERROR;
        ERROR: state <= IDLE;
        default: state <= IDLE; // 需要额外处理非法状态
      endcase
    end
  end
  
  // 组合逻辑输出
  always @(*) begin
    alarm = (state == 3'b000); // 检测到非法状态000时报警
  end
  
endmodule

处理后RTL：

module FSM_Good (
  input wire clk,
  input wire rst_n,
  output reg alarm
);
  
  parameter IDLE  = 3'b001;
  parameter WORK  = 3'b010;
  parameter ERROR = 3'b100;
  
  reg [2:0] state = IDLE; // 初始化为合法状态
  
  // 复位时强制加载IDLE状态
  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) state <= IDLE;  // 复位到合法状态
    else begin
      case(state)
        IDLE:  state <= WORK;
        WORK:  state <= ERROR;
        ERROR: state <= IDLE;
      endcase // 不需要default分支
    end
  end
  
  // 输出逻辑（不再检测非法状态）
  always @(*) begin
    alarm = (state == ERROR);
  end
  
endmodule

场景三：复位期间的输出行为与接口协议

• 必要性： 当模块的输出连接到外部设备或其他需要遵守特定协议的模块时，在复位生效瞬间，输出信号必须处于协议允许的安全状态（通常是高阻态、无效电平或特定空闲值）。不能出现未定义电平、毛刺或违反协议的行为。

• 不处理的后果： 损坏外部设备、违反协议、总线冲突。

• 举例：

  • 三态总线驱动器： 一个驱动外部共享数据总线的模块。

    • 不处理： 复位信号异步生效，瞬间将模块内部的输出使能信号 (oe_n) 和控制数据 (data_out) 的寄存器清零。如果 oe_n 寄存器比 data_out 寄存器更快清零（或反之），可能在总线上产生一个短暂的驱动冲突（oe_n 有效时 data_out 是未定义的X）或者一个无效的数据毛刺。这可能会损坏连接到同一总线的其他器件或违反总线协议。

    • 处理：

      • 在复位生效 (rst_n = 0) 时，强制输出使能信号 (oe_n) 为无效（高阻态）。这通常通过将 oe_n 寄存器的异步置位端（假设低有效使能）连接到复位信号 rst_n 来实现。这样，复位生效瞬间，无论 oe_n 寄存器内部状态如何变化，其输出都会被强制拉高（进入高阻态）。

      • 对于 data_out，虽然其值在复位期间不重要（因为输出已高阻），但为了避免内部逻辑冒险，也应尽量使其复位到一个确定值（通常为0）。更重要的是确保 oe_n 的复位行为优先且安全。这是对复位生效时关键输出信号行为的显式控制。

处理前RTL：

module BusDriver_Bad (
  input wire clk,
  input wire rst_n,
  output tri data_out,
  output reg oe_n // 输出使能（0=驱动总线）
);
  
  reg [7:0] data;
  
  // 数据寄存器复位
  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) data <= 8'hFF;
    else data <= ...; // 正常数据更新
  end
  
  // 使能信号复位（错误：复位后使能有效！）
  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) oe_n <= 0; // 复位后oe_n=0（开始驱动总线！）
    else oe_n <= ...;      // 正常逻辑
  end
  
  assign data_out = oe_n ? 8'bZZZZZZZZ : data; // 三态控制
  
endmodule

处理后RTL：

module BusDriver_Good (
  input wire clk,
  input wire rst_n,
  output tri data_out,
  output reg oe_n = 1'b1 // 初始化为高阻态
);
  
  reg [7:0] data;
  
  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) data <= 0;
    else data <= ...;
  end
  
  // 关键改进：复位时强制oe_n=1（高阻态）
  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) oe_n <= 1'b1; // 复位后立即高阻
    else oe_n <= ...;         // 正常逻辑
  end
  
  assign data_out = oe_n ? 8'bZZZZZZZZ : data;
  
endmodule

场景四：复位期间的待处理操作完成（有限场景）

• 必要性： 在极少数高可靠性或数据完整性要求极高的场景（如写入非易失性存储器、完成关键数据传输），系统可能需要允许复位请求生效后，延迟实际复位的发生，以完成当前正在进行的、不能被中断的关键操作。复位生效的“时刻”被推迟。

• 不处理的后果： 数据丢失/损坏、操作不完整。

• 举例：

  • 向 Flash 存储器写入数据： Flash 写操作一旦启动就不能被中断，否则会导致被写扇区损坏或数据错误。

    • 不处理： 用户按下复位按钮（复位生效），复位信号立刻异步拉低，CPU 和 Flash 控制器立即复位。Flash 写操作被强行终止在半途，导致写入失败和可能的扇区损坏。

    • 处理：

      1. 复位按钮按下（复位请求生效 rst_req_n = 0)。

      2. “复位管理单元”检测到 rst_req_n 有效。

      3. 该单元查询 Flash 控制器状态。如果 Flash 控制器正在执行写/擦除操作：

         • 阻止复位信号 (sys_rst_n) 立即生效（保持为高）。

         • 等待 Flash 控制器完成当前操作（或超时）。

      4. 一旦操作完成（或超时），复位管理单元才让 sys_rst_n 生效（拉低），复位整个系统（包括 CPU 和 Flash 控制器）。

      • 核心： 复位请求 (rst_req_n) 的生效被识别，但实际的功能复位 (sys_rst_n) 的生效被延迟处理，直到满足安全条件。这是对复位生效时机的主动控制。

处理前RTL：

module FlashWriter_Bad (
  input wire clk,
  input wire rst_n,
  input wire write_req
);
  
  reg flash_busy;
  
  always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      flash_busy <= 0; // 复位立即停止写入
    end
    else if (write_req) begin
      flash_busy <= 1;
      // 启动Flash写入操作...
    end
  end
  
endmodule

处理后RTL：

module FlashWriter_Good (
  input wire clk,
  input wire rst_n_async, // 原始异步复位
  input wire write_req
);
  
  // 内部功能复位信号（延迟生效）
  reg functional_rst_n = 1'b1; 
  
  reg flash_busy;
  reg [1:0] reset_fsm;
  
  // 复位管理状态机
  always @(posedge clk or negedge rst_n_async) begin
    if (!rst_n_async) begin
      reset_fsm <= 2'b00;  // 检测到复位请求
    end
    else case(reset_fsm)
      2'b00: // 等待Flash空闲
        if (!flash_busy) reset_fsm <= 2'b01;
      
      2'b01: // 触发功能复位
        begin
          functional_rst_n <= 0;
          reset_fsm <= 2'b10;
        end
        
      2'b10: // 保持复位
        functional_rst_n <= 0;
    endcase
  end
  
  // Flash写入控制（受functional_rst_n复位）
  always @(posedge clk or negedge functional_rst_n) begin
    if (!functional_rst_n) begin
      flash_busy <= 0;
    end
    else if (write_req) begin
      flash_busy <= 1;
      // 启动安全的写入操作...
    end
  end
  
endmodule