分类 IP&SOC设计下的文章 - 我的学记|刘航宇的博客

登录 / 注册

IP&SOC设计(共12篇)

找到 12 篇与 IP&SOC设计相关的结果

数字IC设计项目高性能FFT芯片设计（前后端全流程）本项目为数字集成电路设计基于 SMIC 0.18 μm 工艺，完成了 16 点基-4 FFT 算法的芯片级前后端全流程设计，涵盖 RTL 建模、功能仿真、逻辑综合（DC）与物理实现（ICC）。最终芯片工作频率达到 135 MHz，面积 4.6953 mm²，单次 FFT 能耗 5.25×10⁻⁶ mJ。文章末尾有芯片设计源码与项目其他文件，包含：前端RTL源码、中端DC源码脚本、后端ICC源码脚本、项目报告、参考文件等。目录一、设计规范简介1.1 功能描述 1.2 性能指标能耗计算单位面积功耗时间操作次数二、电路性能分析与结构设计2.1 性能估算面积开销运算性能吞吐率带宽工作频率 2.2 硬件结构图 2.3 流水线时序设计 2.4 时序过程三、RTL 模型与仿真验证3.1 验证方法 3.2 验证平台搭建 3.3 仿真验证结果3.3.1 功能点验证 3.3.2 第一组数据验证对比 3.3.3 测试向量 3.3.4 仿真性能统计四、逻辑综合策略与结果4.1 逻辑综合流程参数设置 4.2 逻辑综合结果时序结果面积结果功耗结果资源使用设计违例五、物理实现与结果分析5.1 ICC 设计步骤5.1.1 数据设定 (Data Setup) 5.1.2 布局规划 (Floorplanning) 5.1.3 布局 (Placement) 5.1.4 时钟树综合 (CTS) 5.1.5 布线 (Routing) 5.2 ICC 设计结果5.2.1 芯片概貌 5.2.2 时序结果 5.2.3 面积结果 5.2.4 功耗结果 5.2.5 芯片压降 5.2.6 拥塞分析 5.2.7 资源使用 5.2.8 设计违例六、设计总结6.1 遇到的主要问题 6.2 相应的解决思路 6.3 关键优化点乘法器优化（频率提升核心）七、参考资料八、项目工程下载（源码、文档和参考文献）一、设计规范简介 1.1 功能描述本次课程设计的核心目标是实现一个高能效的快速傅里叶变换（FFT）电路，具体规格如下：算法：16 点基-4 FFT 算法输入数据：实部与虚部均为 17 bit（1 bit 符号位 + 8 bit 整数位 + 8 bit 小数位）旋转因子：实部与虚部均为 8 bit（1 bit 符号位 + 7 bit 数据位）数据格式：定点数表示，如图 1 所示图 1 16 点基-4 FFT 蝶形运算原理图 pasted_1785032408236_t4qsdl.png图片图 2 数据表示方式（17 bit 输入 / 8 bit 旋转因子）运算数据的实部虚部均为17 bit 而旋转因子的实部与虚部为8 bit pm2xSTf.png图片1.2 性能指标评价指标具体数值完成一次 16 点 FFT 运算的能耗5.25118208 × 10⁻⁶ mJ单位面积功耗时间 FFT 操作次数4.1987688 × 10⁴ 次/(mm²·mW·s)工作频率135.135135 MHz面积开销4.695300 mm²能耗计算单次 FFT 能耗 = 每秒能耗 / 每秒 FFT 运算次数 = 44.3512 mW/s / (1 / (16 × 7.4 ns)) = 5.251182 × 10⁻⁶ mJ单位面积功耗时间操作次数单位面积功耗时间 FFT 操作次数 = 每秒 16 点 FFT 运算次数 / (面积 × 功耗 × 时间) = (1 / (16 × 7.4 ns)) / (4.535456 mm² × 44.3512 mW × 1 s) = 4.1987688 × 10⁴ 次/(mm²·mW·s)二、电路性能分析与结构设计 2.1 性能估算面积开销芯片共有 90 个管脚，布局尺寸计算如下：长：76 μm × 23 + 210 μm × 2 = 2168 μm = 2.168 mm 宽：76 μm × 22 + 210 μm × 2 = 2092 μm = 2.092 mm 总面积：2.168 mm × 2.092 mm = 4.535456 mm² pasted_1785034131111_9ws1vf.png图片运算性能每秒可完成 FFT 运算次数 = 1 s / (16 × 7.4 ns) = 8.445946 × 10⁶ 次吞吐率芯片采用串行输入输出方式，每 16 个周期完成一次信号输入，从输入第 13 个信号时开始蝶形运算，经过 8 个周期完成运算，再经过 16 个周期输出：单次运算周期：13 + 8 + 16 = 37 个周期单次运算吞吐率：1 / (37 × 7.4 ns) = 3.65 × 10⁶ 次/秒由于采用了三级流水线架构，在连续运算足够多的情况下：流水运算周期：16 个周期（每周期输出一个结果）流水吞吐率：1 / (16 × 7.4 ns) = 8.45 × 10⁶ 次/秒带宽存储器时钟频率和数据输入速度保持恒定，峰值带宽与平均带宽相同：带宽 = 17 bit × 2(实部+虚部) × 135.135135 MHz = 4.595 Gbps工作频率工作频率 = 1 / 时钟周期 = 1 / 7.4 ns = 135.135135 MHz2.2 硬件结构图图 3 电路硬件结构图 pm2x9k8.png图片整个电路分为以下模块：模块名称文件名模块类型功能描述控制模块ctrl时序逻辑控制电路中各个模块的运行时序串转并模块s_p时序逻辑将串行输入的数据整合为并行并改变顺序复选器mux时序逻辑按照 FFT 级数选择进入运算模块的数据中转存储模块reg1时序逻辑存储并转发两级 FFT 运算间的运算数据运算模块（蝶形运算）butterfly组合逻辑进行四输入蝶形运算乘法器multi16组合逻辑计算数据与旋转因子间的乘法并转串模块p_s时序逻辑将并行输出的数据分解为串行并倒位序2.3 流水线时序设计时钟周期1-1617-2122-2930-37input第 N 组输入数据到 REG1第 N+1 组输入数据到 REG1——calculate—两级蝶形运算两级蝶形运算—output——第 N-1 组从 REG3 输出第 N 组从 REG3 输出2.4 时序过程 pasted_1785033901140_9815cd.png图片三、RTL 模型与仿真验证 3.1 验证方法 FFT 芯片的验证包括两部分：输出结果验证：通过 testbench 输入数据，将仿真输出与理论正确结果对比流水线验证：一次输入多组数据，观察电路是否能流水式执行 3.2 验证平台搭建在 ModelSim SE-64 10.1c 中，将所有模块的 Verilog 代码通过 top 文件连接，撰写 testbench 从指定文本文件读入输入数据并进行计算。 3.3 仿真验证结果 3.3.1 功能点验证取三组输入作为测试向量，验证输出结果正确性与流水线功能。图 4 测试波形（流水线时序验证） pmR29yj.png图片从波形可见，p_s 模块数据按预期工作：每周期进入 4 个数据，逐个输出，上一组数据输出完毕后下一周期立即输出下一组，流水式执行衔接良好。3.3.2 第一组数据验证对比 X[k]理论输出（实部）实际输出（实部）理论输出（虚部）实际输出（虚部）X[0]0_00010010_000000000_00010001_110010000_00010010_000000000_00010001_10111000X[1]0_00000101_011011100_00000101_010111101_11110000_101110101_11110000_11100101X[2]1_11110110_000000001_11110110_001001100_00000100_001111100_00000100_00101101X[3]0_00000010_000011010_00000010_000000110_00001010_010111000_00001010_00111100X[4]0_00001000_000000000_00000111_111011001_11110110_000000001_11110110_00101000X[5]1_11110110_001100001_11110111_010011010_00000011_100100000_00000011_10000100X[6]0_00000011_001010110_00000011_000111000_00000010_111000000_00000001_01100101X[7]0_00000000_011011010_00000000_011101000_00000010_111000000_00000010_11100001X[8]0_00000010_000000000_00000010_000010001_11111110_000000001_11111110_00001000X[9]0_00000101_111000010_00000101_110100101_11111111_111101011_11111111_11110111X[10]1_11110110_000000001_11110110_001001101_11111011_110000011_11111011_11010001X[11]0_00001001_010000100_00001001_001001110_00000100_111100110_00000100_11100010X[12]1_11111100_000000001_11111100_000111001_11111010_000000001_11111010_00011000X[13]1_11111101_011111111_11111101_100010110_00000011_101111110_00000011_10110000X[14]0_00001000_110101000_00001000_101100001_11111110_100101011_11111110_10011101X[15]1_11110100_010000101_11110100_011010101_11110101_110011111_11110101_11110001图 5 Transcript 输出 pasted_1785032904139_lcns0m.png图片通过对比可知，实际输出与理论输出的实部与虚部均十分接近，在误差范围内可认为相等（存在数据位宽限制等不可避免的截断误差）。第二组、第三组数据经同样验证，结果一致。3.3.3 测试向量第一组测试向量： 0000000010000000000000000000000000 0000000000000000000000000000000000 0000000010000000000000000000000000 0000000000000000000000000000000000 0000000110000000000000000000000000 0000000100000000000000010000000000 0000000010000000000000100000000000 0000000100000000000000001000000000 0000000010000000000000000000000000 0000000100000000000000010000000000 0000000010000000000000000000000000 0000000000000000000000000000000000 0000000010000000000000000000000000 0000000010000000000000000000000000 0000000010000000000000000000000000 0000000010000000000000000000000000第二组测试向量：全 1 序列（16 个相同数据）第三组测试向量：仅第一个数据为 1，其余为 0 3.3.4 仿真性能统计 ✅ 成功实现 16 点 FFT 算法，输出结果与理论值一致 ✅ 每周期输入一个数据，每周期输出一个数据 ✅ 成功实现流水式运行 ✅ 多次测试输出结果稳定，未出现错误四、逻辑综合策略与结果 4.1 逻辑综合流程使用 Synopsys Design Compiler (DC) 进行逻辑综合，主要流程：指定库文件 → 读入设计(转GTECH) → 定义环境 → 设计约束 → 编译策略 → 综合优化 → 存储网表pasted_1785034037920_i4ehar.png图片参数设置参数数值工艺SMIC 0.18 μm时钟周期7.4 ns输入输出延迟3.7 ns工作电压1.62 V运行温度125 ℃面积约束0（无约束）互连模型balanced_tree时钟延时4.3 ns不确定时钟0.5 ns过渡时钟0.2 ns端口最大过渡3 ns4.2 逻辑综合结果时序结果项目时间 (ns)clock clk (rise edge)7.40clock network delay (ideal)4.30clock uncertainty-0.50clk slack (MET)0.007.4 ns 时钟符合设计要求，换算工作频率约为 135 MHz。面积结果项目数量项目面积 (μm²)Ports70Combinational area1,483,546.41Nets140Non-combinational area153,599.85Cells71Net Interconnect area2,089,790.57References3Total Area3,726,936.83功耗结果项目数值Global Operating Voltage1.62 VCell Internal Power756.0848 mWNet Switching Power375.6310 mWTotal Dynamic Power1.1317 WCell Leakage Power28.5281 μW资源使用项目数量Hierarchical Cell85 个Hierarchical Port5,373 个Leaf Cell16,473 个Buf/Inv Cell2,815 个Total Number of Nets18,037 个设计违例 ✅ 电路逻辑综合结果中无设计违例五、物理实现与结果分析 5.1 ICC 设计步骤使用 Synopsys IC Compiler (ICC) 进行物理实现，分为四个阶段： pasted_1785034197720_i2g0so.png图片 5.1.1 数据设定 (Data Setup) 读入逻辑和时序库文件、SDC 约束文件、门级网表，以及 IO 物理库文件、TF 工艺文件、TLU+ 文件等物理数据。 5.1.2 布局规划 (Floorplanning) 定义所有管脚（输入输出、时钟、初始信号）及电源组添加电源环，生成基本布局规划尝试标准单元虚拟布局（create_fp_placement -timing_driven）分析拥塞（面积利用率设置不高，拥塞问题较少）形成电源网络，分析时序，调整电源管脚位置使电压降 < 10% 5.1.3 布局 (Placement) 遵循 NDR 规则，特殊信号线（如 clock）加宽、加大间距执行 place_opt 进行布局布局优化（解决建立时间违例）拥塞分析与优化 5.1.4 时钟树综合 (CTS) 生成时钟网络，加入 buffer 解决负载和 slew time 问题执行 clock_opt 单时钟同步设计，CTS 工作较简单 5.1.5 布线 (Routing) 全局布线 → 轨道分配 → DRC 修复先对时钟布线（route_group -all_clock_nets）解决 verify_lvs 报错（查阅资料后确认无实质影响）解决虚拟机内存不足导致的闪退问题（清理空间后完成） 5.2 ICC 设计结果 5.2.1 芯片概貌图 6 芯片概貌 pasted_1785032971553_0fu3op.png图片顶部和底部各 22 个管脚左边和右边各 23 个管脚共 10 组电源管脚：4 组为管脚供电（分列四周），6 组为内核供电（上下各 1 组，左右各 2 组） 5.2.2 时序结果阶段input (ns)output (ns)clk (ns)data_setup——0.48data_setup_zic1.430.481.19floorplan0.95-1.02-1.39placement1.010.590.19cts_only_psyn1.260.820.62cts_only_cts1.260.830.36route_initial1.350.880.65route_final1.350.850.015.2.3 面积结果图 7 芯片面积测量 pasted_1785033659880_dlug93.png图片 | 项目 | 面积或长度 |Combinational Area1,477,888.21 μm²Non-combinational Area154,248.50 μm²Net Area0.00 μm²Net X Length620,954.62 nmNet Y Length666,869.44 nmCell Area1,632,136.71 μm²Design Area1,632,136.71 μm²Net Length1,287,824.00 nmTotal Area4,695,300.72 μm²芯片尺寸：2092.38 μm × 2244.00 μm 5.2.4 功耗结果项目数值Global Operating Voltage1.62 VCell Internal Power33.6445 mWNet Switching Power12.7067 mWTotal Dynamic Power44.3512 mWCell Leakage Power26.0446 μW5.2.5 芯片压降图 8 芯片压降分析 pasted_1785033682302_ytnfda.png图片工作电压：1.62 V 最大压降：129.6 mV 压降比例：129.6 / 1620 = 8% < 10%，符合设计要求 5.2.6 拥塞分析图 9 拥塞分析（Placement / Detail Route / Track Assignment / Global Route） pasted_1785033720429_zl0o70.png图片由于芯片面积较大，面积利用率设置不高，拥塞问题较少，顺利解决。5.2.7 资源使用项目数量或利用率Module Cells16,240 个Pins91,614 个IO Pad Cells90 个IO Pins70 个Nets18,151 个Average Pins Per Net3.0535 个Total Std Cell Area514,936.70 μm²Total Pad Cell Area1,612,800.00 μm²Core Size1612.38 × 1764.00 = 2,844,238.32 μm²Pad Core Size1672.38 × 1824.00 = 3,050,421.12 μm²Chip Size2092.38 × 2244.00 = 4,695,300.72 μm²Std cells utilization18.10%Cell/Core Ratio18.10%Cell/Chip Ratio45.32%Number of Cell Rows350图 10 单元密度分布 pasted_1785033741857_8nbcxl.png图片5.2.8 设计违例 ✅ 最终设计无设计违例六、设计总结 6.1 遇到的主要问题管脚数量过多，芯片面积过大电路计算结果不正确时序模块数据传输不同步，拖慢运算速度芯片工作频率过低芯片电压降问题 6.2 相应的解决思路问题解决方案管脚过多、面积过大采用串并转换减少管脚；改用基-4 FFT 算法并复用蝶形运算模块减小面积计算结果不正确手动计算关键中间数据，逐一比对各模块输入输出，逐个修复 bug数据传输不同步在时序电路传输标志信号的同时，用组合逻辑电路传输数据，避免同步问题工作频率过低重写乘法器：将乘法运算改为组合逻辑状态机判断旋转因子，采用移位方法完成乘法，频率从 82 MHz 提升至 135 MHz电压降问题增加供电管脚数量并调整位置，最大压降控制在 8%（何卫锋老师指导）6.3 关键优化点乘法器优化（频率提升核心）优化前： assign mul = in_17bit[16:0] * in_8bit[7:0]; // 直接乘法，延迟大优化后： always @ (in_17bit or in_8bit) begin case (in_8bit) 8'b00000000: neg_mul = 25'b0; 8'b01111111: neg_mul = (in_17bit << 7); // ... 其他旋转因子用移位实现 endcase end通过 set_flatten true 和 compile –map high 策略，将工作频率从 82 MHz 大幅提升至 135 MHz。七、参考资料 [1] FFT 算法相关教材与文献 [2] Synopsys Design Compiler 用户手册 [3] Synopsys IC Compiler 用户手册 [4] SMIC 0.18 μm 工艺设计套件文档项目成果总结：本项目完整实践了数字 IC 设计的前后端全流程，从 RTL 编码、功能仿真、逻辑综合到物理实现，成功将 16 点基-4 FFT 算法芯片化。通过架构优化（串并转换、流水线）、算法优化（基-4 复用）、电路优化（组合逻辑移位乘法器），在 SMIC 0.18 μm 工艺下实现了 135 MHz 工作频率、4.70 mm² 面积、5.25×10⁻⁶ mJ 单次运算能耗的优异性能指标。八、项目工程下载（源码、文档和参考文献）包含：前端RTL源码、中端DC源码脚本、后端ICC源码脚本、项目报告、参考文件等

FPGA&ASIC IP&SOC设计 VLSI&IC验证 # VLSI # ASIC/FPGA # TCL脚本 # SOC设计

刘航宇 7月26日
1 83 6
SoC架构、通信举例、AHB、APB接口典型的SoC包括以下部分 CPU与SRAM通信 CPU与I2C接口通信 AHB从接口 AHB主接口 APB桥 APB Slave框图 AXI总线 AXI传输对比 AMBA中AXI AHP APB比较典型的SoC包括以下部分 • 一个或多个处理器内核，可以是MCU、MPU、数字信号处理器或专用指令集处理器内核; • 存储器：可以是RAM、ROM、EEPROM或闪存; • 用于提供时间脉冲信号的振荡器和锁相环电路; • 由计数器和计时器、电源电路组成的外设; • 不同标准的连线接口，如USB、火线、以太网、通用异步收发; • 用于在数字信号和模拟信号之间转换的ADC/DAC; • 电压调理电路及稳压器。在外设内部，各组件通过芯片上的互联总线相互连接。ARM公司推出的 AMBA片上总线主要包括高性能系统总线AHB、通用系统总线ASB、外围互联总线APB、可拓展接口AXI。AHB主要针对高效率、高频宽及快速系统模块；ASB可用于某些高速且不必要使用AHB 总线的场合作为系统总线；APB 主要用于低速、低功率的外围，AXI在AMBA3.0协议中增加，可以用于ARM 和FPGA的高速数据交互。基于ARM的SoC 图片 CPU与SRAM通信 CPU通过AHB对SRAM进行读写地址生成：CPU生成要访问的SRAM地址。信号发送：CPU通过AHB总线发送地址信息和读写请求信号。数据传输：读操作：CPU发送读请求后，SRAM将数据放在数据线上，CPU接收数据。写操作：CPU将数据放在数据线上，发送写请求，SRAM接收并存储数据。等待确认：操作完成后，SRAM可能通过AHB的握手信号通知CPU操作已完成。 CPU与I2C接口通信 CPU通过APB读取I2C的数据 I2C是一种串行通信协议，通常用于低速外围设备与主控制器之间的通信。APB是一种用于连接低速外设的总线。以下是CPU通过APB读取I2C数据的一般步骤：初始化I2C外设：CPU通过APB发送指令初始化I2C外设，设置通信参数如时钟速率、地址等。发送启动条件：CPU通过I2C外设发送启动条件，开始通信。地址和读写位：CPU发送目标设备的I2C地址以及读写位（读操作为1，写操作为0）。数据传输：写操作：如果读写位为0，CPU通过APB发送数据到I2C外设，然后发送停止条件结束通信。读操作：如果读写位为1，CPU接收来自I2C外设的数据。数据接收：在读取操作中，CPU通过APB从I2C外设接收数据。发送停止条件：操作完成后，CPU发送停止条件，结束I2C通信。 AHB从接口图片图片 AHB主接口图片图片 APB桥 APB桥为AHB的一个从设备，但它在APB中是唯一的主设备，而APB中其它低速和低功率消耗的外围皆为APB桥的从设备。下图是 APB 桥的信号接口：图片 APB桥将系统总线传送转换成APB方式的传送，它具备一些这些功能：锁存地址，在传送过程中保持地址有效。锁存读写控制信号对锁存的地址进行译码并产生选择信号PSELx，在传送过程中只有一个选择信号可以被激活。也就是选择出唯一一个APB从设备以进行读写动作. 写操作时: 负责将AHB送来的数据送上APB总线。读操作时: 负责将APB的数据送上AHB系统总线。产生一时序选通信号PENABLE作为数据传递时的启动信号 APB Slave框图图片如前面所提及，APB 总线中除了 APB bridge 为 M 外，其它的外围皆为 S。因此，APB 从设备比 AHB从设备接口较为简单且非常具弹性: 例如 a. APB 少了仲裁器及复杂的译码电路，APB 进行写操作时，从设备可以决定: ：在 PCLK 上升沿触发，且 PSEL 为高时锁存数据：或在 PENABLE 上升沿, 且 PSEL 为高时锁存数据 b. PSELx，PADDR和PWRITE信号的组合可以决定哪个寄存器会被写操作更新。 c. 在读操作的时候，数据可以 PWRITE 在＝0，PSELx 和 PENABLE＝1 的时候被送到总线上，而PADDR 用于决定哪个寄存器会被读。 AXI总线 AXI的三种类型 AXI(AXI4-Full):用于高性能的存储器映射需求；（占用资源较多，传输大量数据） AXI4-Lite：简化版的AXI4接口；（占用资源较少，可用于低吞吐率的存储器的通信） AXI4-Stream：用于高速的流数据通信（不使用地址，适用于视频流） AXI的工作方式 AXI4和AXI4-Lite包含5个独立的通道读地址通道读数据通道写地址通道写数据通道写响应通道图片 AXI4：由于读写地址通道是分离的，所以支持双向同时传输；突发长度最大为256； AXI4-Lite：和AXI4比较类似，但是不支持突发传输； AXI4-Stream：和AXI4的写数据通道比较类似，只有一个单一的数据通道，突发长度不受限制； AXI传输对比 Burst可以减少地址通道的交互，提升单笔传输的效率。 Outstanding可以较少多笔传输之间的等待，提升多笔传输的效率。 AMBA中AXI AHP APB比较图片

IP&SOC设计 # SOC设计

刘航宇 2年前
0 1,413 2
嵌入式/SOC开发利器-ZYNQ简介与入门 ZYNQ是什么？ ZYNQ为什么厉害 ZYNQ的结构开发工具 ZYNQ开发流程 ZYNQ是什么？这是一款由Xilinx公司开发的集成了ARM处理器和FPGA可编程逻辑的片上系统（SoC）芯片。ZYNQ7000有多个型号，根据处理器核心数和FPGA系列的不同，可以应用于多种领域，如图像处理，通信，嵌入式系统等。 ZYNQ中国人读法 “zingke”、“任克”，“Soc”，英文全称叫 System on one Chip ，也就是片上系统的意思。没有微机基础的同学可能不明白什么叫Soc，但是你可以细细琢磨一下，我们的手机和台式电脑的不同，你就可以理解Soc的内含了。传统计算机是将CPU，内存，GPU，南北桥焊接在印刷电路板上，各个组件之间是分立的。但是Soc则将CPU和各种外设集中到一块芯片上，集合成一个系统，因此像手机这种使用了Soc芯片的这种微机可以做的很轻薄，我们可以说，Soc是未来微机发展的一个趋势，我之前遇见过的像什么全志的A33就是典型的Soc。 ZYNQ为什么厉害就在于它是一块可编程的Soc。其内部往往有处理器硬核和一些定制外设，并且外设当中有一个很厉害的玩意：PL，即可编程逻辑模块，也就是我们一般意义上的FPGA，所以简单理解ZYNQ就是“ 单片机 + FPGA “，它既可以执行代码程序，也可以实现FPGA。因此我们设计ZYNQ就是在做Soc设计。 ZYNQ的结构我们先来开一下简化版的模型图片上面的模型细致低展开后就是下图的样子：图片图是 ZYNQ 7000的结构图，大体分为PS（Processing System）和 PL（Programmable Logic）两部分，其中的PS部分主要是由双核APU和外围的一些外设组成，说实话很像单片机的结构，而外围的PL则类似FPGA，并且两者通过AXI接口进行互联以实现功能. 重点介绍一下APU，应用处理单元：Application Processing Unit，位于PS（processing system）中，包括一个单核或者双核的cortex-A9处理器，处理器连接一个512KB的共享L2cache，每个处理器都有一个32KB的高速L1 cache，A9支持虚拟内存和32bit arm 指令。APU中的A9处理器由可配置的MP组成，MP包含SCU（snoop control unit：监控控制单元）单元，这个单元主要负责获取两个处理器的L1 cache和ACP（accelerator coherency port：加速器相关接口） PL的一致性。应用单元还有一个低延迟的片上memory，与L2 cache并行的，ACP（加速器接口）是PL与APU通信接口，该接口是PL作为主机的AXI协议的接口，最多支持64bit位宽，PL通过ACP接口访问L2 cache 和片上memory，同时保持和L1 cache的内存一致性。L2 cache 可以访问 DDR 控制，这个ddr 控制器是专用的，大大降低内存读写的延迟APU 还包括一个32bit的看门狗，一个64bit的全局定时器，APU 架构图如下所示：图片开发工具在Vivado 19.2之前，我们开发Zynq需要三样必须的软件： Vivado SDK PetaLinux 其中Vivado用来开发硬件平台，SDK开发软件，PetaLinux则制作配套的Linux系统。可能有些人还有用到HLS ，即VIvado HLS 或者Vitis HLS；其中Vivado HLS 2020.1将是Vivado HLS的最后一个版本，取而代之的是VitisHLS。到了Vivado 19.2之后，事情发生了变化。为了方便大家理解，我愿意称之这些软件成了为Vitis 家族的各个部分，原来的SDK被Vitis IDE取代，Vivado导出的 .hdf 文件被 .xsa文件代替，用来给vitis平台使用。因此我们需要的开发Zynq 最基本的软件变成了 Vivado Vitis IDE PetaLinux 各软件发挥的作用和之前的差不多，不过除了上面提到的四款软件外，Vitis家族还有 Vitis AI 等组件，他们共同组成了所谓的“Vitis™ Unified Software Platform ”，从发展趋势来看，这些开发软件应该会逐步的统一，入门的同学也不会再一头雾水地纠结 Vitis 和 Vivado 的区别和联系了。 ZYNQ开发流程 ZYNQ类似于一个单片机 + FPGA的结构，其实我觉得如果大家接触过一些 Soc就会更好地理解ZYNQ的作用，就例如全志A33这块Soc，它是一块ASIC，不可以通过编程来对芯片的硬件进行重设计的。图片我们可以看到，灰色部分的外设都是固定的，像什么摄像头接口，什么视频接口都是设计好的，定制化的好处就使得总体比较高效，制造成本也低；但是如果我要运用到其它场景下，比如说我需要多个摄像头，那这块芯片就不再适合了（硬件控制的上限就是前后两颗摄像头）而ZYNQ的意义相当于只给你定制的蓝色部分，也就是处理器内核，灰色的部分都可以通过FPGA实现，这让电子工程师们可以快速开发出各种各样有针对性的Soc；当然了，看过我第一篇博客的同学都知道，其实固定的硬核不止只有处理器内核，其实还有串口和内存控制器之类的外设，这其实是追寻一种固定和变化之间的平衡。咱们把话说回ZYNQ的开发上来。图片 ZYNQ的开发流程分为硬件和软件两部分，在SDK之前的属于硬件开发，也就是我们常说的PL部分的开发，而SDK后就属于软件部分的开发了，类似单片机，属于PS部分。当然现在最新的Vitis IDE已经取代了SDK，所以后半部分一般在SDK中进行。 PL部分的开发包括对嵌入式最小系统的构建，以及FPGA外设的设计两个方面。我觉得要转变的一个思维是，我们现在不是在开发一个什么SDRAM控制器，什么IIC协议控制器，我们在开发的是一个小型的微机系统！因此嵌入式最小系统的设计是我们的核心。首先，在IP INTEGRATOR中我们要创建BLOCK DESIGN。图片 IP是用来进行 Embedded System Design ，也就是咱们常说的嵌入式系统设计。也就是咱们上面说的嵌入式最小系统的设计。图片大家可以看到，一个最小的系统其实不需要PL参与的，PL可以作为PS的一个外设使用，或者是自己做自己的事情，仅仅作为一个PL工作。既然是外设，当然是可用可不用的，毕竟咱们有好多的外设可以在Block Design 中直接配置使用，即下图绿色部分。图片配置好嵌入式系统后，咱们根据需要进行PL部分的设计。这里涉及一个问题，那就是PS和PL之间的数据传输方式有哪些：中断 IO方式：MIO EMIO GPIO BRAM或FIFO或EMIF AXI DMA：PS通过AXI-lite向AXI DMA发送指令，AXI DMA通过HP通路和DDR交换数据，PL通过AXI-S读写DMA的数据。等等。。。可以看出，其实两个部分的交互方式还是很多的，以后咱们遇到一个说一个。在Vivado端完成对嵌入式系统的设计后，我们就要进入Vitis IDE 端进行软件的开发。图片 Vitis IDE简单来说流程一般是：新建一个工程，选择Platform ，也就是我们之前在Vivado中生成的 XSA文件，然后添加文件，进行开发。我相信使用过Keil 5的同学们应该心中对文件目录结构应该更胸有成竹，Src文件夹中存放的是源文件。代码编写完之后是编译，编译完就是下载了。不过这里要注意以下，如果我们使用了PL的资源，那么在下载软件编译生成的 elf 文件之前，需要先下载硬件设计过程中生成的 bitstream 文件，对 PL 部分进行配置。最后就是验证工作了，上述的流程是普通的ZYNQ开发流程；玩的花一点的同学可能是直接上Linux操作系统，这部分等后面我接触到了再说吧！其实我觉得ZYNQ入门简单，精通的话需要大量的知识储备，但也不是不可能，开发ZYNQ相比于做单片机开发肯定路子会更广一些，向上可以做IC设计，向下嵌入式、单片机什么的工作也能胜任。

FPGA&ASIC IP&SOC设计 # ASIC/FPGA # 嵌入式 # SOC设计

刘航宇 3年前
0 4,689 5
2023-07-10
Verilog实现AMBA--AHB To APB Bridge 1、APB桥 2、读传输 3、写传输 4、背靠背传输 5、AHB_to_APB Bridge的Verilog实现 6、仿真 1、APB桥 APB桥是AMBA APB总线上的唯一主机，也是AMBA AHB的一个从机。下图表示了APB桥接口信号：图片 APB Bridge将AHB传输转成APB传输并实现一下功能：（1）对锁存的地址进行译码并产生选择信号PSELx，在传输过程中只有一个选择信号可以被激活。也就是选择出唯一一个APB从设备以进行读写动作。（2）写操作时：负责将AHB送来的数据送上APB总线。（3）读操作时：负责将APB的数据送上AHB系统总线。（4）产生一时序选通信号PENABLE来作为数据传递时的启动信号 2、读传输下图表示了APB到AHB的读传输：图片传输开始于AHB总线上的T1时刻，在T2时刻地址信息被APB采样，如果传输目标是外设总线，那么这个地址就会被译码成选择信号发给外设，T2即为APB总线的SETUP周期，T3为APB的ENABLE周期，PENABLE信号拉高。在该周期内，外设必须提供读数据，通常情况下，读数据直接AHB读数据总线上，总线主机在T4时刻对读数据进行采样。在频率很高的情况下，在ENABLE CYCLE中可能数据不能够直接映射到AHB总线，需要在APB桥中在T4的时候打插入一个额外的等待周期，并在T5的时候才被AHB主采样。虽然需要多一个等待周期（一共2个），但是由于频率提升了因此总的性能也提升了。下图表示了一个读突发传输，所有的传输都只有一个等待周期图片 3、写传输下图表示了一个写传输：图片 APB总线上的单块数据写操作不需要等待周期。 APB桥负责对地址和数据进行采样，并在写操作的过程中保持它们的值。下图表示了一个写突发传输：图片虽然第一个传输可以零等待完成，但后续每一个传输都需要插入一个等待状态。 APB桥需要两个地址寄存器，以便在当前传输进行时，锁存下一次传输的地址。 4、背靠背传输下图表示了一个背靠背传输，顺序为写、读、写、读：如果写操作之后跟随着读操作，那么需要 3 个等待周期来完成这个读操作。通常的情况下，不会有读操作之后紧跟着写操作的发生，因为两者之间 CPU 会进行指令读取，并且指令存储器也不太可能挂在在APB总线上。图片下面以ARM DesignStart项目提供的软件包里的AHB转APB桥的代码，对其进行学习与仿真，以深入理解APB桥的实现方法，该转换桥比较简单，实现的是一对一的转换，也可以配合APB slave multiplexer模块，实现一对多的方式（主要依靠APB高位地址译码得到各个从机的PSEL信号）。如果想学习APB系统总线，可以参考Synopsys公司的DW_APB IP，该IP最多可支持16个APB从机，并支持所有的突发传输类型。 5、AHB_to_APB Bridge的Verilog实现 `timescale 1ns / 1ps module ahb_to_apb #( // Parameter to define address width // 16 = 2^16 = 64KB APB address space parameter ADDRWIDTH = 16, parameter REGISTER_RDATA = 1, parameter REGISTER_WDATA = 0 ) ( //---------------------------------- // IO Declarations //---------------------------------- input wire HCLK, // Clock input wire HRESETn, // Reset input wire PCLKEN, // APB clock enable signal input wire HSEL, // Device select input wire [ADDRWIDTH-1:0] HADDR, // Address input wire [1:0] HTRANS, // Transfer control input wire [2:0] HSIZE, // Transfer size input wire [3:0] HPROT, // Protection control input wire HWRITE, // Write control input wire HREADY, // Transfer phase done input wire [31:0] HWDATA, // Write data output reg HREADYOUT, // Device ready output wire [31:0] HRDATA, // Read data output output wire HRESP, // Device response // APB Output output wire [ADDRWIDTH-1:0] PADDR, // APB Address output wire PENABLE, // APB Enable output wire PWRITE, // APB Write output wire [3:0] PSTRB, // APB Byte Strobe output wire [2:0] PPROT, // APB Prot output wire [31:0] PWDATA, // APB write data output wire PSEL, // APB Select output wire APBACTIVE, // APB bus is active, for clock gating of APB bus // APB Input input wire [31:0] PRDATA, // Read data for each APB slave input wire PREADY, // Ready for each APB slave input wire PSLVERR // Error state for each APB slave ); //---------------------------------- // Variable Declarations //---------------------------------- reg [ADDRWIDTH-3:0] addr_reg; // Address sample register reg wr_reg; // Write control sample register reg [2:0] state_reg; // State for finite state machine reg [3:0] pstrb_reg; // Byte lane strobe register wire [3:0] pstrb_nxt; // Byte lane strobe next state reg [1:0] pprot_reg; // PPROT register wire [1:0] pprot_nxt; // PPROT register next state wire apb_select; // APB bridge is selected wire apb_tran_end; // Transfer is completed on APB reg [2:0] next_state; // Next state for finite state machine reg [31:0] rwdata_reg; // Read/Write data sample register wire reg_rdata_cfg; // REGISTER_RDATA paramater wire reg_wdata_cfg; // REGISTER_WDATA paramater reg sample_wdata_reg; // Control signal to sample HWDATA //---------------------------------- // Local Parameter Declarations //---------------------------------- // State machine localparam ST_BITS = 3; localparam [ST_BITS-1:0] ST_IDLE = 3'b000; // Idle waiting for transaction localparam [ST_BITS-1:0] ST_APB_WAIT = 3'b001; // Wait APB transfer localparam [ST_BITS-1:0] ST_APB_TRNF = 3'b010; // Start APB transfer localparam [ST_BITS-1:0] ST_APB_TRNF2 = 3'b011; // Second APB transfer cycle localparam [ST_BITS-1:0] ST_APB_ENDOK = 3'b100; // Ending cycle for OKAY localparam [ST_BITS-1:0] ST_APB_ERR1 = 3'b101; // First cycle for Error response localparam [ST_BITS-1:0] ST_APB_ERR2 = 3'b110; // Second cycle for Error response localparam [ST_BITS-1:0] ST_ILLEGAL = 3'b111; // Illegal state //---------------------------------- // Start of Main Code //---------------------------------- // Configuration signal assign reg_rdata_cfg = (REGISTER_RDATA == 0) ? 1'b0 : 1'b1; assign reg_wdata_cfg = (REGISTER_WDATA == 0) ? 1'b0 : 1'b1; // Generate APB bridge select assign apb_select = HSEL & HTRANS[1] & HREADY; // Generate APB transfer ended assign apb_tran_end = (state_reg == 3'b011) & PREADY; assign pprot_nxt[0] = HPROT[1]; // (0) Normal, (1) Privileged assign pprot_nxt[1] = ~HPROT[0]; // (0) Data, (1) Instruction // Byte strobe generation // - Only enable for write operations // - For word write transfers (HSIZE[1]=1), all byte strobes are 1 // - For hword write transfers (HSIZE[0]=1), check HADDR[1] // - For byte write transfers, check HADDR[1:0] assign pstrb_nxt[0] = HWRITE & ((HSIZE[1])|((HSIZE[0])&(~HADDR[1]))|(HADDR[1:0]==2'b00)); assign pstrb_nxt[1] = HWRITE & ((HSIZE[1])|((HSIZE[0])&(~HADDR[1]))|(HADDR[1:0]==2'b01)); assign pstrb_nxt[2] = HWRITE & ((HSIZE[1])|((HSIZE[0])&( HADDR[1]))|(HADDR[1:0]==2'b10)); assign pstrb_nxt[3] = HWRITE & ((HSIZE[1])|((HSIZE[0])&( HADDR[1]))|(HADDR[1:0]==2'b11)); // Sample control signals always @(posedge HCLK or negedge HRESETn) begin if (~HRESETn) begin addr_reg <= {(ADDRWIDTH-2){1'b0}}; wr_reg <= 1'b0; pprot_reg <= {2{1'b0}}; pstrb_reg <= {4{1'b0}}; end else if (apb_select) begin // Capture transfer information at the end of AHB address phase addr_reg <= HADDR[ADDRWIDTH-1:2]; wr_reg <= HWRITE; pprot_reg <= pprot_nxt; pstrb_reg <= pstrb_nxt; end end // Sample write data control signal // Assert after write address phase, deassert after PCLKEN=1 wire sample_wdata_set = apb_select & HWRITE & reg_wdata_cfg; wire sample_wdata_clr = sample_wdata_reg & PCLKEN; always @(posedge HCLK or negedge HRESETn) begin if (~HRESETn) sample_wdata_reg <= 1'b0; else if (sample_wdata_set | sample_wdata_clr) sample_wdata_reg <= sample_wdata_set; end // Generate next state for FSM // Note : case 3'b111 is not used. The design has been checked that // this illegal state cannot be entered using formal verification. always @(state_reg or PREADY or PSLVERR or apb_select or reg_rdata_cfg or PCLKEN or reg_wdata_cfg or HWRITE) begin case (state_reg) // Idle ST_IDLE : begin if (PCLKEN & apb_select & ~(reg_wdata_cfg & HWRITE)) next_state = ST_APB_TRNF; // Start APB transfer in next cycle else if (apb_select) next_state = ST_APB_WAIT; // Wait for start of APB transfer at PCLKEN high else next_state = ST_IDLE; // Remain idle end // Transfer announced on AHB, but PCLKEN was low, so waiting ST_APB_WAIT : begin if (PCLKEN) next_state = ST_APB_TRNF; // Start APB transfer in next cycle else next_state = ST_APB_WAIT; // Wait for start of APB transfer at PCLKEN high end // First APB transfer cycle ST_APB_TRNF : begin if (PCLKEN) next_state = ST_APB_TRNF2; // Change to second cycle of APB transfer else next_state = ST_APB_TRNF; // Change to state-2 end // Second APB transfer cycle ST_APB_TRNF2 : begin if (PREADY & PSLVERR & PCLKEN) // Error received - Generate two cycle // Error response on AHB by next_state = ST_APB_ERR1; // Changing to state-5 and 6 else if (PREADY & (~PSLVERR) & PCLKEN) begin // Okay received if (reg_rdata_cfg) // Registered version next_state = ST_APB_ENDOK; // Generate okay response in state 4 else // Non-registered version next_state = {2'b00, apb_select}; // Terminate transfer end else // Slave not ready next_state = ST_APB_TRNF2; // Unchange end // Ending cycle for OKAY (registered response) ST_APB_ENDOK : begin if (PCLKEN & apb_select & ~(reg_wdata_cfg & HWRITE)) next_state = ST_APB_TRNF; // Start APB transfer in next cycle else if (apb_select) next_state = ST_APB_WAIT; // Wait for start of APB transfer at PCLKEN high else next_state = ST_IDLE; // Remain idle end // First cycle for Error response ST_APB_ERR1 : next_state = ST_APB_ERR2; // Goto 2nd cycle of error response // Second cycle for Error response ST_APB_ERR2 : begin if (PCLKEN & apb_select & ~(reg_wdata_cfg & HWRITE)) next_state = ST_APB_TRNF; // Start APB transfer in next cycle else if (apb_select) next_state = ST_APB_WAIT; // Wait for start of APB transfer at PCLKEN high else next_state = ST_IDLE; // Remain idle end default : // Not used next_state = 3'bxxx; // X-Propagation endcase end // Registering state machine always @(posedge HCLK or negedge HRESETn) begin if (~HRESETn) state_reg <= 3'b000; else state_reg <= next_state; end // Sample PRDATA or HWDATA always @(posedge HCLK or negedge HRESETn) begin if (~HRESETn) rwdata_reg <= {32{1'b0}}; else if (sample_wdata_reg & reg_wdata_cfg & PCLKEN) rwdata_reg <= HWDATA; else if (apb_tran_end & reg_rdata_cfg & PCLKEN) rwdata_reg <= PRDATA; end // Connect outputs to top level assign PADDR = {addr_reg, 2'b00}; // from sample register assign PWRITE = wr_reg; // from sample register // From sample register or from HWDATA directly assign PWDATA = (reg_wdata_cfg) ? rwdata_reg : HWDATA; assign PSEL = (state_reg == ST_APB_TRNF) | (state_reg == ST_APB_TRNF2); assign PENABLE = (state_reg == ST_APB_TRNF2); assign PPROT = {pprot_reg[1], 1'b0, pprot_reg[0]}; assign PSTRB = pstrb_reg[3:0]; // Generate HREADYOUT always @(state_reg or reg_rdata_cfg or PREADY or PSLVERR or PCLKEN) begin case (state_reg) ST_IDLE : HREADYOUT = 1'b1; // Idle ST_APB_WAIT : HREADYOUT = 1'b0; // Transfer announced on AHB, but PCLKEN was low, so waiting ST_APB_TRNF : HREADYOUT = 1'b0; // First APB transfer cycle // Second APB transfer cycle: // if Non-registered feedback version, and APB transfer completed without error // Then response with ready immediately. If registered feedback version, // wait until state_reg == ST_APB_ENDOK ST_APB_TRNF2 : HREADYOUT = (~reg_rdata_cfg) & PREADY & (~PSLVERR) & PCLKEN; ST_APB_ENDOK : HREADYOUT = reg_rdata_cfg; // Ending cycle for OKAY (registered response only) ST_APB_ERR1 : HREADYOUT = 1'b0; // First cycle for Error response ST_APB_ERR2 : HREADYOUT = 1'b1; // Second cycle for Error response default : HREADYOUT = 1'bx; // x propagation (note :3'b111 is illegal state) endcase end // From sample register or from PRDATA directly assign HRDATA = (reg_rdata_cfg) ? rwdata_reg : PRDATA; assign HRESP = (state_reg == ST_APB_ERR1) | (state_reg == ST_APB_ERR2); assign APBACTIVE = (HSEL & HTRANS[1]) | (|state_reg); endmodule使用的测试用例和AHB从机的测试用例基本一样，首先是顶层： `timescale 1ns / 1ps module top_tb(); //---------------------------------- // Local Parameter Declarations //---------------------------------- localparam AHB_CLK_PERIOD = 5; // Assuming AHB CLK to be 100MHz localparam SIZE_IN_BYTES = 2048; localparam ADDRWIDTH = 32; //---------------------------------- // Variable Declarations //---------------------------------- reg HCLK = 0; wire HWRITE; wire [1:0] HTRANS; wire [2:0] HSIZE; wire [2:0] HBURST; wire HREADYIN; wire [31:0] HADDR; wire [3:0] HPROT; wire [31:0] HWDATA; wire HREADYOUT; wire [1:0] HRESP; wire [31:0] HRDATA; reg HRESETn; wire HREADY; wire [ADDRWIDTH-1:0] PADDR; // APB Address wire PENABLE; // APB Enable wire PWRITE; // APB Write wire [31:0] PWDATA; // APB write data wire PSEL; // APB Select wire PREADY; wire PSLVERR; wire [2:0] PPROT; wire [3:0] PSTRB; wire [31:0] PRDATA; //---------------------------------- // Start of Main Code //---------------------------------- assign HREADY = HREADYOUT; //----------------------------------------------------------------------- // Generate HCLK //----------------------------------------------------------------------- always #AHB_CLK_PERIOD HCLK <= ~HCLK; //----------------------------------------------------------------------- // Generate HRESETn //----------------------------------------------------------------------- initial begin HRESETn = 1'b0; repeat(5) @(posedge HCLK); HRESETn = 1'b1; end ahb_master #( .START_ADDR (32'h0), .DEPTH_IN_BYTES (SIZE_IN_BYTES) ) u_ahb_master ( .HRESETn (HRESETn), .HCLK (HCLK), .HADDR (HADDR), .HPROT (HPROT), .HTRANS (HTRANS), .HWRITE (HWRITE), .HSIZE (HSIZE), .HBURST (HBURST), .HWDATA (HWDATA), .HRDATA (HRDATA), .HRESP (HRESP), .HREADY (HREADYOUT) ); ahb_to_apb #( .ADDRWIDTH (ADDRWIDTH), .REGISTER_RDATA (0), .REGISTER_WDATA (0) ) u_ahb_to_apb( .HCLK (HCLK), .HRESETn (HRESETn), .PCLKEN (1'b1), .HSEL (1'b1), .HADDR (HADDR), .HTRANS (HTRANS), .HSIZE (HSIZE), .HPROT (HPROT), .HWRITE (HWRITE), .HREADY (HREADY), .HWDATA (HWDATA), .HREADYOUT (HREADYOUT), .HRDATA (HRDATA), .HRESP (HRESP), .PADDR (PADDR), .PENABLE (PENABLE), .PWRITE (PWRITE), .PREADY (PREADY), .PSLVERR (PSLVERR), .PSTRB (PSTRB), .PPROT (PPROT), .PWDATA (PWDATA), .PSEL (PSEL), .APBACTIVE (APBACTIVE), .PRDATA (PRDATA) ); apb_mem #( .P_SLV_ID (0), .ADDRWIDTH (ADDRWIDTH), .P_SIZE_IN_BYTES (SIZE_IN_BYTES), .P_DELAY (0) ) u_apb_mem ( `ifdef AMBA_APB3 .PREADY (PREADY), .PSLVERR (PSLVERR), `endif `ifdef AMBA_APB4 .PSTRB (PSTRB), .PPROT (PPROT), `endif .PRESETn (HRESETn), .PCLK (HCLK), .PSEL (PSEL), .PENABLE (PENABLE), .PADDR (PADDR), .PWRITE (PWRITE), .PRDATA (PRDATA), .PWDATA (PWDATA) ); `ifdef VCS initial begin $fsdbDumpfile("top_tb.fsdb"); $fsdbDumpvars; end initial begin `ifdef DUMP_VPD $vcdpluson(); `endif end `endif endmodule然后是AHB master的功能模型： `timescale 1ns / 1ps `define SINGLE_TEST `define BURST_TEST module ahb_master #( //---------------------------------- // Paramter Declarations //---------------------------------- parameter START_ADDR = 0, parameter DEPTH_IN_BYTES = 32'h100, parameter END_ADDR = START_ADDR+DEPTH_IN_BYTES-1 ) ( //---------------------------------- // IO Declarations //---------------------------------- input wire HRESETn, input wire HCLK, output reg [31:0] HADDR, output reg [1:0] HTRANS, output reg HWRITE, output reg [2:0] HSIZE, output reg [2:0] HBURST, output reg [3:0] HPROT, output reg [31:0] HWDATA, input wire [31:0] HRDATA, input wire [1:0] HRESP, input wire HREADY ); //---------------------------------- // Variable Declarations //---------------------------------- reg [31:0] data_burst[0:1023]; //---------------------------------- // Start of Main Code //---------------------------------- initial begin HADDR = 0; HTRANS = 0; HPROT = 0; HWRITE = 0; HSIZE = 0; HBURST = 0; HWDATA = 0; while(HRESETn === 1'bx) @(posedge HCLK); while(HRESETn === 1'b1) @(posedge HCLK); while(HRESETn === 1'b0) @(posedge HCLK); `ifdef SINGLE_TEST repeat(3) @(posedge HCLK); memory_test(START_ADDR, END_ADDR, 1); memory_test(START_ADDR, END_ADDR, 2); memory_test(START_ADDR, END_ADDR, 4); `endif `ifdef BURST_TEST repeat(5) @(posedge HCLK); memory_test_burst(START_ADDR, END_ADDR, 1); memory_test_burst(START_ADDR, END_ADDR, 2); memory_test_burst(START_ADDR, END_ADDR, 4); memory_test_burst(START_ADDR, END_ADDR, 6); memory_test_burst(START_ADDR, END_ADDR, 8); memory_test_burst(START_ADDR, END_ADDR, 10); memory_test_burst(START_ADDR, END_ADDR, 16); memory_test_burst(START_ADDR, END_ADDR, 32); memory_test_burst(START_ADDR, END_ADDR, 64); memory_test_burst(START_ADDR, END_ADDR, 128); memory_test_burst(START_ADDR, END_ADDR, 255); repeat(5) @(posedge HCLK); `endif $finish(2); end //----------------------------------------------------------------------- // Single transfer test //----------------------------------------------------------------------- task memory_test; input [31:0] start; // start address input [31:0] finish; // end address input [2:0] size; // data size: 1, 2, 4 integer i; integer error; reg [31:0] data; reg [31:0] gen; reg [31:0] got; reg [31:0] reposit[START_ADDR:END_ADDR]; begin $display("%m: read-after-write test with %d-byte access", size); error = 0; gen = $random(7); for (i = start; i < (finish-size+1); i = i + size) begin gen = $random & ~32'b0; data = align(i, gen, size); ahb_write(i, size, data); ahb_read(i, size, got); got = align(i, got, size); if (got !== data) begin $display("[%10d] %m A:%x D:%x, but %x expected", $time, i, got, data); error = error + 1; end end if (error == 0) $display("[%10d] %m OK: from %x to %x", $time, start, finish); $display("%m read-all-after-write-all with %d-byte access", size); error = 0; gen = $random(1); for (i = start; i < (finish-size+1); i = i + size) begin gen = {$random} & ~32'b0; data = align(i, gen, size); reposit[i] = data; ahb_write(i, size, data); end for (i = start; i < (finish-size+1); i = i + size) begin data = reposit[i]; ahb_read(i, size, got); got = align(i, got, size); if (got !== data) begin $display("[%10d] %m A:%x D:%x, but %x expected", $time, i, got, data); error = error + 1; end end if (error == 0) $display("[%10d] %m OK: from %x to %x", $time, start, finish); end endtask //----------------------------------------------------------------------- // Burst transfer test //----------------------------------------------------------------------- task memory_test_burst; input [31:0] start; // start address input [31:0] finish; // end address input [7:0] leng; // burst length integer i; integer j; integer k; integer r; integer error; reg [31:0] data; reg [31:0] gen; reg [31:0] got; reg [31:0] reposit[0:1023]; integer seed; begin $display("[%10d] %m: read-all-after-write-all burst test with %d-beat access", $time, leng); error = 0; seed = 111; gen = $random(seed); k = 0; if (finish > (start+leng*4)) begin for (i = start; i < (finish-(leng*4)+1); i = i + leng*4) begin for (j = 0; j < leng; j = j + 1) begin data_burst[j] = $random; reposit[j+k*leng] = data_burst[j]; end @(posedge HCLK); ahb_write_burst(i, leng); k = k + 1; end gen = $random(seed); k = 0; for (i = start; i < (finish-(leng*4)+1); i = i + leng*4) begin @(posedge HCLK); ahb_read_burst(i, leng); for (j = 0; j < leng; j = j + 1) begin if (data_burst[j] != reposit[j+k*leng]) begin error = error+1; $display("[%10d] %m A=%hh D=%hh, but %hh expected", $time, i+j*leng, data_burst[j], reposit[j+k*leng]); end end k = k + 1; r = $random & 8'h0F; repeat(r) @(posedge HCLK); end if (error == 0) $display("%m %d-length burst read-after-write OK: from %hh to %hh",leng, start, finish); end else begin $display("%m %d-length burst read-after-write from %hh to %hh ???",leng, start, finish); end end endtask //----------------------------------------------------------------------- // As AMBA AHB bus uses non-justified data bus scheme, data should be // aligned according to the address. //----------------------------------------------------------------------- function [31:0] align; input [ 1:0] addr; input [31:0] data; input [ 2:0] size; // num of bytes begin `ifdef BIG_ENDIAN case (size) 1 : case (addr[1:0]) 0 : align = data & 32'hFF00_0000; 1 : align = data & 32'h00FF_0000; 2 : align = data & 32'h0000_FF00; 3 : align = data & 32'h0000_00FF; endcase 2 : case (addr[1]) 0 : align = data & 32'hFFFF_0000; 1 : align = data & 32'h0000_FFFF; endcase 4 : align = data&32'hFFFF_FFFF; default : $display($time,,"%m ERROR %d-byte not supported for size", size); endcase `else case (size) 1 : case (addr[1:0]) 0 : align = data & 32'h0000_00FF; 1 : align = data & 32'h0000_FF00; 2 : align = data & 32'h00FF_0000; 3 : align = data & 32'hFF00_0000; endcase 2 : case (addr[1]) 0 : align = data & 32'h0000_FFFF; 1 : align = data & 32'hFFFF_0000; endcase 4 : align = data&32'hFFFF_FFFF; default : $display($time,,"%m ERROR %d-byte not supported for size", size); endcase `endif end endfunction `include "ahb_transaction_tasks.v" endmoduleahb_transaction_tasks.v文件如下： `ifndef __AHB_TRANSACTION_TASKS_V__ `define __AHB_TRANSACTION_TASKS_V__ //----------------------------------------------------------------------- // AHB Read Task //----------------------------------------------------------------------- task ahb_read; input [31:0] address; input [2:0] size; output [31:0] data; begin @(posedge HCLK); HADDR <= #1 address; HPROT <= #1 4'b0001; // DATA HTRANS <= #1 2'b10; // NONSEQ; HBURST <= #1 3'b000; // SINGLE; HWRITE <= #1 1'b0; // READ; case (size) 1 : HSIZE <= #1 3'b000; // BYTE; 2 : HSIZE <= #1 3'b001; // HWORD; 4 : HSIZE <= #1 3'b010; // WORD; default : $display($time,, "ERROR: unsupported transfer size: %d-byte", size); endcase @(posedge HCLK); while (HREADY !== 1'b1) @(posedge HCLK); HTRANS <= #1 2'b0; // IDLE @(posedge HCLK); while (HREADY === 0) @(posedge HCLK); data = HRDATA; // must be blocking if (HRESP != 2'b00) $display($time,, "ERROR: non OK response for read"); @(posedge HCLK); end endtask //----------------------------------------------------------------------- // AHB Write Task //----------------------------------------------------------------------- task ahb_write; input [31:0] address; input [2:0] size; input [31:0] data; begin @(posedge HCLK); HADDR <= #1 address; HPROT <= #1 4'b0001; // DATA HTRANS <= #1 2'b10; // NONSEQ HBURST <= #1 3'b000; // SINGLE HWRITE <= #1 1'b1; // WRITE case (size) 1 : HSIZE <= #1 3'b000; // BYTE 2 : HSIZE <= #1 3'b001; // HWORD 4 : HSIZE <= #1 3'b010; // WORD default : $display($time,, "ERROR: unsupported transfer size: %d-byte", size); endcase @(posedge HCLK); while (HREADY !== 1) @(posedge HCLK); HWDATA <= #1 data; HTRANS <= #1 2'b0; // IDLE @(posedge HCLK); while (HREADY === 0) @(posedge HCLK); if (HRESP != 2'b00) $display($time,, "ERROR: non OK response write"); @(posedge HCLK); end endtask //----------------------------------------------------------------------- // AHB Read Burst Task //----------------------------------------------------------------------- task ahb_read_burst; input [31:0] addr; input [31:0] leng; integer i; integer ln; integer k; begin k = 0; @(posedge HCLK); HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b10; // NONSEQ if (leng >= 16) begin HBURST <= #1 3'b111; // INCR16 ln = 16; end else if (leng >= 8) begin HBURST <= #1 3'b101; // INCR8 ln = 8; end else if (leng >= 4) begin HBURST <= #1 3'b011; // INCR4 ln = 4; end else begin HBURST <= #1 3'b001; // INCR ln = leng; end HWRITE <= #1 1'b0; // READ HSIZE <= #1 3'b010; // WORD @(posedge HCLK); while (HREADY == 1'b0) @(posedge HCLK); while (leng > 0) begin for (i = 0; i < ln-1; i = i + 1) begin HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b11; // SEQ; @(posedge HCLK); while (HREADY == 1'b0) @(posedge HCLK); data_burst[k%1024] <= HRDATA; k = k + 1; end leng = leng - ln; if (leng == 0) begin HADDR <= #1 0; HTRANS <= #1 0; HBURST <= #1 0; HWRITE <= #1 0; HSIZE <= #1 0; end else begin HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b10; // NONSEQ if (leng >= 16) begin HBURST <= #1 3'b111; // INCR16 ln = 16; end else if (leng >= 8) begin HBURST <= #1 3'b101; // INCR8 ln = 8; end else if (leng >= 4) begin HBURST <= #1 3'b011; // INCR4 ln = 4; end else begin HBURST <= #1 3'b001; // INCR1 ln = leng; end @(posedge HCLK); while (HREADY == 0) @(posedge HCLK); data_burst[k%1024] = HRDATA; // must be blocking k = k + 1; end end @(posedge HCLK); while (HREADY == 0) @(posedge HCLK); data_burst[k%1024] = HRDATA; // must be blocking end endtask //----------------------------------------------------------------------- // AHB Write Burst Task // It takes suitable burst first and then incremental. //----------------------------------------------------------------------- task ahb_write_burst; input [31:0] addr; input [31:0] leng; integer i; integer j; integer ln; begin j = 0; ln = 0; @(posedge HCLK); while (leng > 0) begin HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b10; // NONSEQ if (leng >= 16) begin HBURST <= #1 3'b111; // INCR16 ln = 16; end else if (leng >= 8) begin HBURST <= #1 3'b101; // INCR8 ln = 8; end else if (leng >= 4) begin HBURST <= #1 3'b011; // INCR4 ln = 4; end else begin HBURST <= #1 3'b001; // INCR ln = leng; end HWRITE <= #1 1'b1; // WRITE HSIZE <= #1 3'b010; // WORD for (i = 0; i < ln-1; i = i + 1) begin @(posedge HCLK); while (HREADY == 1'b0) @(posedge HCLK); HWDATA <= #1 data_burst[(j+i)%1024]; HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b11; // SEQ; while (HREADY == 1'b0) @(posedge HCLK); end @(posedge HCLK); while (HREADY == 0) @(posedge HCLK); HWDATA <= #1 data_burst[(j+i)%1024]; if (ln == leng) begin HADDR <= #1 0; HTRANS <= #1 0; HBURST <= #1 0; HWRITE <= #1 0; HSIZE <= #1 0; end leng = leng - ln; j = j + ln; end @(posedge HCLK); while (HREADY == 0) @(posedge HCLK); if (HRESP != 2'b00) begin // OKAY $display($time,, "ERROR: non OK response write"); end `ifdef DEBUG $display($time,, "INFO: write(%x, %d, %x)", addr, size, data); `endif HWDATA <= #1 0; @(posedge HCLK); end endtask `endif还需要一个APB的从机模块： `timescale 1ns / 1ps `define AMBA_APB3 `define AMBA_APB4 module apb_mem #( parameter P_SLV_ID = 0, parameter ADDRWIDTH = 32, parameter P_SIZE_IN_BYTES = 1024, // memory depth parameter P_DELAY = 0 // reponse delay ) ( //---------------------------------- // IO Declarations //---------------------------------- `ifdef AMBA_APB3 output wire PREADY, output wire PSLVERR, `endif `ifdef AMBA_APB4 input wire [2:0] PPROT, input wire [3:0] PSTRB, `endif input wire PRESETn, input wire PCLK, input wire PSEL, input wire PENABLE, input wire [ADDRWIDTH-1:0] PADDR, input wire PWRITE, output reg [31:0] PRDATA = 32'h0, input wire [31:0] PWDATA ); //---------------------------------- // Local Parameter Declarations //---------------------------------- localparam DEPTH = (P_SIZE_IN_BYTES+3)/4; localparam AW = logb2(P_SIZE_IN_BYTES); //---------------------------------- // Variable Declarations //---------------------------------- `ifndef AMBA_APB3 wire PREADY; `else assign PSLVERR = 1'b0; `endif `ifndef AMBA_APB4 wire [3:0] PSTRB = 4'hF; `endif reg [7:0] mem0[0:DEPTH-1]; reg [7:0] mem1[0:DEPTH-1]; reg [7:0] mem2[0:DEPTH-1]; reg [7:0] mem3[0:DEPTH-1]; wire [AW-3:0] TA = PADDR[AW-1:2]; //---------------------------------- // Start of Main Code //---------------------------------- //-------------------------------------------------------------------------- // write transfer // ____ ____ ____ // PCLK ___| |____| |____| |_ // ____ ___________________ _____ // PADDR ____X__A________________X_____ // ____ ___________________ _____ // PWDATA ____X__DW_______________X_____ // ___________________ // PWRITE ____| |_____ // ___________________ // PSEL ____| |_____ // _________ // PENABLE ______________| |_____ //-------------------------------------------------------------------------- always @(posedge PCLK) begin if (PRESETn & PSEL & PENABLE & PWRITE & PREADY) begin if (PSTRB[0]) mem0[TA] <= PWDATA[ 7: 0]; if (PSTRB[1]) mem1[TA] <= PWDATA[15: 8]; if (PSTRB[2]) mem2[TA] <= PWDATA[23:16]; if (PSTRB[3]) mem3[TA] <= PWDATA[31:24]; end end //-------------------------------------------------------------------------- // read // ____ ____ ____ // PCLK ___| |____| |____| |_ // ____ ___________________ _____ // PADDR ____X__A________________X_____ // ____ _________ _____ // PRDATA ____XXXXXXXXXXX__DR_____X_____ // ____ _____ // PWRITE ____|___________________|_____ // ___________________ // PSEL ____| |_____ // _________ // PENABLE ______________| |_____ //-------------------------------------------------------------------------- always @(posedge PCLK) begin if (PRESETn & PSEL & ~PENABLE & ~PWRITE) begin PRDATA[ 7: 0] <= mem0[TA]; PRDATA[15: 8] <= mem1[TA]; PRDATA[23:16] <= mem2[TA]; PRDATA[31:24] <= mem3[TA]; end end `ifdef AMBA_APB3 localparam ST_IDLE = 'h0, ST_CNT = 'h1, ST_WAIT = 'h2; reg [7:0] count; reg ready; reg [1:0] state=ST_IDLE; assign PREADY = (P_DELAY == 0) ? 1'b1 : ready; always @(posedge PCLK or negedge PRESETn) begin if (PRESETn == 1'b0) begin count <= 'h0; ready <= 'b1; state <= ST_IDLE; end else begin case (state) ST_IDLE : begin if (PSEL && (P_DELAY > 0)) begin ready <= 1'b0; count <= 'h1; state <= ST_CNT; end else begin ready <= 1'b1; end end // ST_IDLE ST_CNT : begin count <= count + 1; if (count >= P_DELAY) begin count <= 'h0; ready <= 1'b1; state <= ST_WAIT; end end // ST_CNT ST_WAIT : begin ready <= 1'b1; state <= ST_IDLE; end // ST_WAIT default : begin ready <= 1'b1; state <= ST_IDLE; end endcase end // if end // always `else assign PREADY = 1'b1; `endif // Calculate log-base2 function integer logb2; input [31:0] value; reg [31:0] tmp; begin tmp = value - 1; for (logb2 = 0; tmp > 0; logb2 = logb2 + 1) tmp = tmp >> 1; end endfunction // synopsys translate_off `ifdef RIGOR always @(posedge PCLK or negedge PRESETn) begin if (PRESETn == 1'b0) begin end else begin if (PSEL & PENABLE) begin if (TA >= DEPTH) $display($time,,"%m: ERROR: out-of-bound 0x%x", PADDR); end end end `endif // synopsys translate_on endmodule6、仿真用VCS进行仿真，打印信息如下图片可见仿真完全正确，这里也只是做了AHB总线的单一传输和各种长度的增量突发，回环突发未涉及（对APB桥来说，它并不关心HBURST的信号值）。下面挂两张仿真截图：单一传输，先写后读：图片突发传输，先写完，再读完图片

IP&SOC设计 # SOC设计

刘航宇 3年前
1 1,577 1
2023-06-20
Microsemi Libero SOC常见问题-FPGA全局网络的设置问题描述最近在一个FPGA工程中分配rst_n引脚时，发现rst_n引脚类型为CLKBUF，而不是常用的INBUF，在分配完引脚commit检查报错，提示需要连接到全局网络引脚上。 Running Global Checker... Error:PLC002:No legal assignment exists for global net rst.n_c. Info:Uhlocking the driver or removing the region constraint for net rst nc may help to satisfy Error:PLC005:Automat ic global net placement failed. 尝试忽略这个错误，直接进行编译，在布局布线时又报错。 Error: PLC002: No legal assignment exists for global net rst_n_c. Error: PLC005: Automatic global net placement failed. Error: Failure when executing Tcl script. [ Line 18 ] 尝试取消引脚锁定LOCK，再次commit检查成功，编译下载正常，但是功能不对，再次打开引脚分配界面，发现是rst_n对应的引脚并不是我设置的那个，看来是CLKBUF的原因。问题分析网络上搜索一些资料后，发现是在一些工程中会出现这个问题，如果rst_n信号连接了许多IP核，和很多自己写的模块，这样rst_n就需要很强的驱动能力，即扇出能力(Fan Out)，而且布线会很长，所以在分配管脚时，IDE自动添加了CLKBUF，来提供更大的驱动能力和更小的延时。那么什么是FPGA的全局时钟网络资源呢？ FPGA全局布线资源简介我们知道FPGA的资源主要由以下几部分组成：可编程输入输出单元（IOB）基本可编程逻辑单元（CLB）数字时钟管理模块（DCM）嵌入块式RAM（BRAM）丰富的布线资源内嵌专用硬件模块。我们重点介绍布线资源，FPGA中布线的长度和工艺决定着信号在的驱动能力和传输速度。FPGA的布线资源可大概分为4类：全局布线资源：芯片内部全局时钟和全局复位/置位的布线长线资源：完成芯片Bank间的高速信号和第二全局时钟信号的布线短线资源：完成基本逻辑单元之间的逻辑互连和布线分布式布线资源：用于专有时钟、复位等控制信号线。一般设计中，我们不需要直接参与布线资源的分配，IDE中的布局布线器（Place and Route）可以根据输入逻辑网表的拓扑结构，和用户设定的约束条件来自动的选择布线资源。其中全局布线资源具有最强的驱动能力和最小的延时，但是只能限制在全局管脚上，厂商会特殊设计这部分资源，如Xilinx FPGA中的全局时钟资源一般使用全铜层工艺实现，并设计了专门时钟缓冲和驱动结构，从而使全局时钟到达芯片内部的所有可配置逻辑单元（CLB）、I/O单元（IOB）和选择性块RAM（Block Select ROM）的时延和抖动都为最小。一般全局布线资源都是针对输入信号来说的，如果IDE自动把rst_n引脚优化为了全局网络，而硬件电路设计上却把rst_n分配到了普通管脚上，那么就很麻烦了，要么牺牲全局网络的优势，手动将全局网络改为普通网络，要么为了利用全局网络的优势，修改电路，重新分配硬件引脚。所以如果一些关键的信号确定了，如时钟、复位等，产品迭代修改电路时，不要轻易调整这些关键引脚。 Microsemi FPGA的全局布线资源 Microsemi FPGA的全局时钟管脚编号，我们可以通过官方Datasheet来找到，在手册中关于全局IO的命名规则上，有如下介绍：即只有管脚名称为GFA0/1/2，GFB0/1/2，GFC0/1/2，GCA0/1/2，GCB0/1/2，GCC0/1/2（共18个）才支持全局网络分配，而且，如果使用了GFA0引脚作为全局输入引脚，那么GFA1和GFA2都不能再作为全局网络了，其他GFC等同理，这一点在设计电路时要特别注意。对于Microsemi SmartFusion系列FPGA芯片A2F200M3F-PQ208来说，只有7个，分别是：GFA0-15、GFA1-14、GFA2-13、GCA0-145、GCA1-146、GCC2-151、GCA2-153，引脚分配如下图所示：所以在设计A2F200M3F-PQ208硬件电路时，时钟和复位信号尽量分配在这些管脚上，以获得硬件性能的最大效率。这些全局引脚的延时时间都是非常小的，具体的时间参数可以从数据手册上获得。全局网络改为普通输入像文章开头介绍的情况，IDE自动把rst_n设置为全局网络，而实际硬件却不是全局引脚，应该怎么修改为普通输入呢？即CLKBUF改为普通的INBUF？网络上zlg的教程中使用的是版本较低的Libero IDE 8.0，新版的Libero SoC改动非常大，文中介绍的修改sdc文件的方法已经不能使用了，这里提供新的修改方法——调用INBUF IP Core的方式。这里官方已经考虑到了，在官方提供的INBUF IP Core可以把CLKBUF改为INBUF。在Catalog搜索框中输入：INBUF，可以看到这里也提供了LVDS信号专用的IP Core。拖动到SmartDesign中进行连接或者在源文件中直接例化的方式调用INBUF Core： INBUF INBUF_0( // Inputs .PAD ( rst_n ), // Outputs .Y ( rst_n_Y ) );这两种方法都是一样的。添加完成之后，再进行管脚分配，可以看到rst_n已经是普通的INBUF类型了，可以进行普通管脚的分配，而且commit检查也是没有错误的。普通输入上全局网络如果布局布线器没有把我们要的信号上全局网络，如本工程的CLK信号，IDE自动生成的是INBUF类型，我们想让他变成CLKBUF，即全局网络，来获取最大的驱动能力和最小的延时。那么应该怎么办呢？这里同样要使用到一个IP Core，和INBUF类似，这个IP Core的名称是CLKBUF，同样是在Catalog目录中搜索：CLKBUF，可以看到有CLKBUF开头的很多Core，这里同样也提供了LVDS信号专用的IP Core。可以直接拖动Core到SmartDesign图形编辑窗口：或者是在源文件中以直接例化的方式调用： CLKBUF CLKBUF_0( // Inputs .PAD ( CLKA ), // Outputs .Y ( CLKA_Y ) );这两种方式都是一样的，添加完成之后，再进行管脚分配，可以看到CLKA已经是全局网络了，只能分配在全局管脚上。总结对于不同厂家的FPGA，让某个信号上全局网络的方法都不尽相同，如Xilinx的FPGA是通过BUFG Core来让信号上全局网络，而且还有带使能端的全局缓冲 BUFGCE ， BUFGMUX 的应用更为灵活，有2个输入，可通过选择端选择输出哪一个。所以，信号的全局缓冲设置要根据不同厂商Core的不同来使用。

嵌入式＆系统 FPGA&ASIC IP&SOC设计 # 嵌入式

刘航宇 3年前
0 1,592 3
Microsemi Libero SOC使用示例—建立点灯工程嵌入式开发中的Hello World，点灯是再也基础不过的实验了，通过点灯实验，可以了解芯片GPIO的控制和开发环境IDE新建工程的流程，对于FPGA来说，每个IO口几乎一样，所以本篇文章主要学习一下如何基于Microsemi Libero集成开发环境建立一个示例工程，让一个LED以500ms的频率闪烁，以Microsemi SmartFusion系列FPGA——A2F200M3F为例，Microsemi其他系列FPGA芯片过程类似。准备工作软件准备：硬件准备：新建工程的主要步骤1.新建工程 2.添加设计文件 3.仿真验证 4.管脚分配 5.程序下载 Microsemi FPGA的Flash结构准备工作工欲利其事，必先利其器，充分的准备工作很有必要。软件准备： Microsemi Libero SoC集成开发环境，并已经成功注册，软件版本推荐V11.8或更高版本。硬件准备： Microsemi FPGA开发板，主控芯片A2F200M3F-PQ208，其他型号芯片类似。 Flash Pro 4或Flash Pro5下载器，用于给FPGA芯片下载程序和调试。新建工程的主要步骤新建工程，选择芯片型号等新建设计，使用Verilog编写点灯模块。仿真验证，对编写的点灯模块进行时序仿真，来验证是否满足设计需求。综合、管脚分配、布局、布线。生成程序文件，连接开发板，使用FlashPro下载程序到芯片内，观察现象是否和设计的一致。 1.新建工程和大多数IDE一样，选择Project -> New Project，新建一个工程。 image.png图片输入工程名称LED_Blink，选择工程存放的路径，工程名称和路径不要有中文字符和空格，选择源文件的类型Verilog或者VHDL。 image.png图片选择芯片型号，这里选择Microsemi SmartFusion系列下的A2F200M3F芯片，PQ208封装，把鼠标放在所选芯片上，可以查看芯片的详细参数：封装、速度等级、温度范围，内核电压、Flash ROM大小、用户IO数目、RAM大小、Flash ROM大小，ARM Cortex-M3 SoC的外设配置等详细的参数。图片选择IO的电平标准，不同的电平标准，高低电平的电压范围是不同的，这里选择默认的LVTTL。图片是否创建MSS模块，MSS里有PLL和ARM Cortex-M3的使用，以后用到PLL和ARM核时再添加，这里先不选择，以后需要也可以再创建。图片是否导入已经存在的HDL文件，如果已经有一些写好的模块，可以在这里直接导入。图片是否导入已经存在的管脚约束文件，这里选择不添加，我们会在后面通过图形化工具来指定管脚。图片到这里，工程就创建完成了，然后会在存储路径下生成一个和工程名称一样的文件夹，工程相关的所以文件都存放在这里。主要包括以下几个文件夹：图片具体每个文件夹存放的是什么文件，我们在以后的文章再详细介绍。以上的工程配置在创建完工程之后，也可以再次更改，可以通过Project->Project Setting查看或更改配置：图片或者通过点击如下图标来进入配置界面：图片弹出如下窗口，和新建工程是一样的，可以更改FPGA的型号，但只限于同一个系列内。 2.添加设计文件 Microsemi Libero开发环境支持HDL方式和SmarDesign方式来创建设计，HDL方式支持VerilogHDL和VHDL两种硬件描述语言，而SmartDesign方式和Xilinx的Schematic原理图方式是一样的，是通过图形化的方式来对各个模块之间的连接方式进行编辑，两种方式都可以完成设计。由于本实验功能简单，所以以使用Verilog文件为例。创建Verilog文件创建Verilog文件有多种方式，可以直接双击左侧菜单中的Create Design->Create HDL 图片或者点击File->New->HDL，这两种方式都可以创建一个Verilog设计文件，这里选择Verilog文件。图片输入模块名称：led_driver，不用添加.v后缀名，Libero软件会自动添加。源代码： module led_driver( //input input clk, //clk=2MHz input rst_n, //0=reset //output output reg led ); parameter T_500MS = 999999; //1M reg [31:0] cnt; always @ (posedge clk) begin if(!rst_n) cnt <= 32'b0; else if(cnt >= T_500MS) cnt <= 32'b0; else //cnt < T_500MS cnt <= cnt + 32'b1; end always @ (posedge clk) begin if(!rst_n) led <= 1'b1; else if(cnt >= T_500MS) led <= ~led; end endmodule可以看到，代码非常的简单，定义一个计数器，系统时钟为2MHz=500ns，500ms=1M个时钟周期，当计数到500ms时，LED翻转闪烁。 3.仿真验证编写完成，之后，点击对号进行语法检查，如果没有语法错误就可以进行时序仿真了。新建Testbench文件底部切换到Design Hierarchy选项卡，在led模块上右键选择Create Testbechch创建仿真文件，选择HDL格式。图片给创建的testbench文件名一般为模块名后加_tb，这里为：led_driver_tb，因为我们的板子外部晶体为2M，所以这里系统时钟周期为500ns，这个也可以在文件中更改。图片点击OK之后，可以看到，Libero软件已经为我们生成了一些基本代码，包括输入端口的定义，系统时钟的产生，输入信号的初始化等等。我们只需要再增加几行即可。 `timescale 1ns/100ps module led_driver_tb; parameter SYSCLK_PERIOD = 500;// 2MHZ reg SYSCLK; reg NSYSRESET; wire led; //add output reg initial begin SYSCLK = 1'b0; NSYSRESET = 1'b0; end initial begin #(SYSCLK_PERIOD * 10 ) NSYSRESET = 1'b0; //add system reset #(SYSCLK_PERIOD * 100 ) NSYSRESET = 1'b1; //add system set end always @(SYSCLK) //generate system clock #(SYSCLK_PERIOD / 2.0) SYSCLK <= !SYSCLK; led_driver led_driver_0 ( // Inputs .clk(SYSCLK), .rst_n(NSYSRESET), // Outputs .led(led ) //add port // Inouts ); endmodule仿真代码也非常简单，输入信号初始化，NSYSRESET在10个时钟周期之后拉低，100个时钟周期之后拉高。使用ModelSim进行时序仿真仿真代码语法检查无误后，可以进行ModelSim自动仿真，在安装Libero时，已经默认安装了ModelSim仿真软件，并和Libero进行了关联。直接双击Simulate，Libero会自动打开ModelSim。图片可以看到输入输出信号，已经为我们添加好了：图片先点击复位按钮，复位系统，然后设置要运行的时间，由于设计的是500ms闪烁一次，这里我们先运行2s，即2000ms，在ModelSim中2秒已经算是很长的时间了，然后点击时间右边的运行按钮，耐心等待，停止之后就会看到led按500ms变化一次的波形了，如下图所示，可以再添加一个cnt信号到波形观察窗口，可以看到cnt周期性的变化。图片使用2个光标的精确测量，可以看出，led每隔500ms翻转一次，说明程序功能是正确的。 4.管脚分配与STM32等MCU不同，FPGA的引脚配置非常灵活，如STM32只有固定的几个引脚才能作为定时器PWM输出，而FPGA通过管脚分配可以设置任意一个IO口输出PWM，而且使用起来非常灵活，这也是FPGA和MCU的一个区别，当然其他的功能，如串口外设，SPI外设等等，都可以根据需要自己用HDL代码来实现，非常方便。时序仿真正常之后，就可以进行管脚分配了，即把模块的输入输出端口，真正的分配到芯片实际的引脚上，毕竟我们的代码是要运行在真正的芯片上的。打开引脚配置图形化界面双击Create/Edit I/O Attributes，打开图形化配置界面，在打开之前，Libero会先进行综合(Synthesize)、编译(Complie)，当都运行通过时，才会打开配置界面。图片分配管脚管脚可视化配置工具使用起来非常简单：引脚号指定、IO的电平标准，内部上下拉等等，非常直观。把时钟、复位、LED这些管脚分配到开发板原理图中对应的引脚，在分配完成之后，可以点击左上角的commit and check进行检查。图片在分配完成之后，为了以后方便查看已经分配的引脚，可以导出一个pdc引脚约束文件，选择Designer窗口下的File->Export->Constraint File，会导出一个led_driver.pdc文件，保存在工程目录下的constraint文件夹。图片一些特殊管脚的处理 SmartFusion系列的FPGA芯片，在分配个别引脚，如35-39、43-47这些引脚时，直接不能分配，这些引脚属于MSS_FIO特殊引脚，具体怎么配置为通用IO，可以查看下一篇文章。而新一代的SmartFusion 2系列的FPGA芯片则没有这种情况。 5.程序下载管脚分配完成之后，连接FlashPro下载器和开发板的JTAG接口，关闭Designer窗口，选择Program Device，耐心等待几分钟，如果连接正常，会在右侧输出编程信息：擦除、验证、编程等操作，下载完成之后，就会看到板子上的LED闪烁起来了。 Microsemi FPGA的Flash结构和Altera、Xilinx不同，Microsemi FPGA在下载程序时，并不是下载程序到SPI Flash，而是直接下载到FPGA内部的。目前，FPGA 市场占有率最高的两大公司Xilinx和Altera 生产的 FPGA 都是基于 SRAM 工艺的，需要在使用时外接一个片外存储器以保存程序。上电时，FPGA 将外部存储器中的数据读入片内 RAM，完成配置后，进入工作状态；掉电后 FPGA 恢复为白片，内部逻辑消失。这样 FPGA 不仅能反复使用，还无需专门的 FPGA编程器，只需通用的 EPROM、PROM 编程器即可。而Microsemi的SmartFusion、SmartFusion2、ProASICS3、ProASIC3E系列基于Flash结构，具备反复擦写和掉电后内容非易失性，因此基于Flash结构的FPGA同时具备了SRAM结构的灵活性和反熔丝结构的可靠性，这种技术是最近几年发展起来的新型FPGA实现工艺，目前实现的成本还偏高，没有得到大规模的应用。示例工程下载基于Libero V11.8.2.4的工程下载： LED_Blink.rar 下载地址：https://wcc-blog.oss-cn-beijing.aliyuncs.com/Libero/Libero-2/LED_Blink.rar 提取码：

嵌入式＆系统 FPGA&ASIC IP&SOC设计 # ASIC/FPGA # 嵌入式 # SOC设计

刘航宇 3年前
0 1,976 2
【IC/CPU设计】极简的RISC_CPU设计 CPU为SOC系统的核心环节，该项目来自于夏宇闻老师的经典教材——《Verilog 数字系统设计教程》，通过此练习方便数字ICer更好的入门本次项目实践环境：前仿： Modelsim 综合： Design Compile 目录 CPU简介整体结构时钟发生器指令寄存器累加器算术运算器数据控制器地址多路器程序计数器状态控制器&主状态机外围模块地址译码器 RAM ROM 顶层模块 TestbenchTest1程序 Test3程序完整的testbench 源代码&脚本前仿真结果 DC后仿真总结源代码&脚本 CPU简介 CPU（Central Processing Unit），中文全称中央处理器，作为四大U之首(CPU/GPU/TPU/NPU），是计算机系统的运算和控制核心，也是当今数字系统中不可或缺的组成部分。CPU自诞生到如今发展超过50年，借助冯诺依曼体系，CPU掀起一股又一股的科技浪潮。RISC作为精简了指令集的CPU，除了指令更加简洁，还拥有简单合理的内部结构，从而提高了运算速度。 CPU工作的5个阶段：（1）取指（IF，Instruction Fetch），将指令从存储器取出到指令寄存器。每取一条指令，程序计数器自加一。（2）译指（ID，Instruction Decode)，对取出的指令按照规定格式进行拆分和译码。（3）执行（EX，Execute），执行具体指令操作。（4）访问存储（MEM，Memory），根据指令访问存储、完成存储和读取。（5）写回（WB，Write Back），将计算结果写回到存储器。 CPU内部关键结构：（1）算术逻辑运算器（ALU）；（2）累加器；（3）程序计数器；（4）指令寄存器和译码器；（5）时序和控制部件。 RISC_CPU内部结构和Verilog实现本项目中的RISC_CPU一共有9个模块组成，具体如下：（1）时钟发生器；（2）指令寄存器；（3）累加器；（4）算术逻辑运算单元；（5）数据控制器；（6）状态控制器；（7）主状态机；（8）程序计数器；（9）地址多路器。整体结构图片时钟发生器模块图： image.png图片端口描述： reset是高电平复位信号； clk是外部时钟信号； fetch是控制信号，是clk的八分频信号；fetch为高电平时，触发执行指令以及地址多路器输出指令地址和数据地址。 alu_ena是算术逻辑运算单元的使能信号。图片可以看到alu_ena提前fetch高电平一个clk周期，fetch是clk的8分频信号。 Verilog代码： // Description: RISC——CPU 时钟发生器 // ----------------------------------------------------------------------------- module clk_gen ( input clk , // Clock input reset , // High level reset output reg fetch , // 8 frequency division output reg alu_ena // Arithmetic enable ); reg [7:0] state; //One-piece state machine parameter S1 = 8'b0000_0001, S2 = 8'b0000_0010, S3 = 8'b0000_0100, S4 = 8'b0000_1000, S5 = 8'b0001_0000, S6 = 8'b0010_0000, S7 = 8'b0100_0000, S8 = 8'b1000_0000, idle = 8'b0000_0000; always@(posedge clk)begin if(reset)begin fetch <= 0; alu_ena <= 0; state <= idle; end else begin case(state) S1: begin alu_ena <= 1; state <= S2; end S2: begin alu_ena <= 0; state <= S3; end S3: begin fetch <= 1; state <=S4; end S4: begin state <= S5; end S5: state <= S6; S6: state <= S7; S7: begin fetch <= 0; state <= S8; end S8: begin state <= S1; end idle: state <= S1; default: state <=idle; endcase end end endmodule指令寄存器模块图：图片端口描述：寄存器是将数据总线送来的指令存入高8位或低8位寄存器中。 ena信号用来控制是否寄存。每条指令为两个字节，16位，高3位是操作码，低13位是地址（CPU地址总线为13位，寻址空间为8K字节）。本设计的数据总线为8位，每条指令需要取两次，先取高8位，再取低8位。 Verilog代码： // Description: RISC—CPU 指令寄存器 // ----------------------------------------------------------------------------- module register ( input [7:0] data , input clk , input rst , input ena , output reg [15:0] opc_iraddr ); reg state ; // always@( posedge clk ) begin if( rst ) begin opc_iraddr <= 16'b 0000_0000_0000_0000; state <= 1'b 0; end // if rst // If load_ir from machine actived, load instruction data from rom in 2 clock periods. // Load high 8 bits first, and then low 8 bits. else if( ena ) begin case( state ) 1'b0 : begin opc_iraddr [ 15 : 8 ] <= data; state <= 1; end 1'b1 : begin opc_iraddr [ 7 : 0 ] <= data; state <= 0; end default : begin opc_iraddr [ 15 : 0 ] <= 16'bxxxx_xxxx_xxxx_xxxx; state <= 1'bx; end endcase // state end // else if ena else state <= 1'b0; end endmodule 累加器模块图：图片端口描述：累加器用于存放当前结果，ena信号有效时，在clk上升沿输出数据总线的数据。 // Description: RISC-CPU 累加器模块 // ----------------------------------------------------------------------------- module accum ( input clk , // Clock input ena , // Enable input rst , // Asynchronous reset active high input [7:0] data , // Data bus output reg [7:0] accum ); always@(posedge clk)begin if(rst) accum <= 8'b0000_0000;//Reset else if(ena) accum <= data; end endmodule 算术运算器模块图： image.png图片端口描述：算术逻辑运算单元可以根据输入的操作码分别实现相应的加、与、异或、跳转等基本操作运算。本单元支持8种操作运算。 opcode用来选择计算模式 data是数据输入 accum是累加器输出 alu_ena是模块使能信号 clk是系统时钟 Verilog代码： // Description: RISC-CPU 算术运算器 // ----------------------------------------------------------------------------- module alu ( input clk , // Clock input alu_ena , // Enable input [2:0] opcode , // High three bits are used as opcodes input [7:0] data , // data input [7:0] accum , // accum out output reg [7:0] alu_out , output zero ); parameter HLT = 3'b000 , SKZ = 3'b001 , ADD = 3'b010 , ANDD = 3'b011 , XORR = 3'b100 , LDA = 3'b101 , STO = 3'b110 , JMP = 3'b111 ; always @(posedge clk) begin if(alu_ena) begin casex(opcode)//操作码来自指令寄存器的输出 opc_iaddr(15..0)的第三位 HLT: alu_out <= accum ; SKZ: alu_out <= accum ; ADD: alu_out <= data + accum ; ANDD: alu_out <= data & accum ; XORR: alu_out <= data ^ accum ; LDA : alu_out <= data ; STO : alu_out <= accum ; JMP : alu_out <= accum ; default: alu_out <= 8'bxxxx_xxxx ; endcase end end assign zero = !accum; endmodule 数据控制器模块图： image.png图片端口描述：数据控制器的作用是控制累加器的数据输出，数据总线是分时复用的，会根据当前状态传输指令或者数据。数据只在往RAM区或者端口写时才允许输出，否则呈现高阻态。 in是8bit数据输入 data_ena是使能信号 data是8bit数据输出 Verilog代码： // Description: RISC-CPU 数据控制器 // ----------------------------------------------------------------------------- module datactl ( input [7:0] in , // Data input input data_ena , // Data Enable output wire [7:0] data // Data output ); assign data = (data_ena )? in: 8'bzzzz_zzzz ; endmodule 地址多路器模块图： image.png图片端口描述：用于选择输出地址是PC（程序计数）地址还是数据/端口地址。每个指令周期的前4个时钟周期用于从ROM种读取指令，输出的是PC地址；后四个时钟周期用于对RAM或端口读写。地址多路器和数据控制器实现的功能十分相似。 fetch信号用来控制地址输出，高电平输出pc_addr ,低电平输出ir_addr ; pc_addr 指令地址； ir_addr ram或端口地址。 Verilog代码： // Description: RISC-CPU 地址多路器 // ----------------------------------------------------------------------------- module adr ( input fetch , // enable input [12:0] ir_addr , // input [12:0] pc_addr , // output wire [12:0] addr ); assign addr = fetch? pc_addr :ir_addr ; endmodule 程序计数器模块图： image.png图片端口描述：程序计数器用来提供指令地址，指令按照地址顺序存放在存储器中。包含两种生成途径：（1）顺序执行的情况（2）需要改变顺序，例如JMP指令 rst复位信号，高电平时地址清零； clock 时钟信号，系统时钟； ir_addr目标地址，当加载信号有效时输出此地址； pc_addr程序计数器地址 load地址装载信号 Verilog代码： // Description: RISC-CPU 程序计数器 // ----------------------------------------------------------------------------- module counter ( input [12:0] ir_addr , // program address input load , // Load up signal input clock , // CLock input rst , // Reset output reg [12:0] pc_addr // insert program address ); always@(posedge clock or posedge rst) begin if(rst) pc_addr <= 13'b0_0000_0000_0000; else if(load) pc_addr <= ir_addr; else pc_addr <= pc_addr + 1; end endmodule 状态控制器&主状态机模块图： image.png图片（图左边）状态机端口描述：状态控制器接收复位信号rst，rst有效，控制输出ena为0，fetch有效控制ena为1。 // Description: RISC-CPU 状态控制器 // ----------------------------------------------------------------------------- module machinectl ( input clk , // Clock input rst , // Asynchronous reset input fetch , // Asynchronous reset active low output reg ena // Enable ); always@(posedge clk)begin if(rst) ena <= 0; else if(fetch) ena <=1; end endmodule （图右边）主状态端口描述：主状态机是CPU的控制核心，用于产生一系列控制信号。指令周期由8个时钟周期组成，每个时钟周期都要完成固定的操作。（1）第0个时钟，CPU状态控制器的输出rd和load_ir 为高电平，其余为低电平。指令寄存器寄存由ROM送来的高8位指令代码。（2）第1个时钟，与上一个时钟相比只是inc_pc从0变为1，故PC增1，ROM送来低8位指令代码，指令寄存器寄存该8位指令代码。（3）第2个时钟，空操作。（4）第3个时钟，PC增1，指向下一条指令。操作符为HLT，输出信号HLT为高。操作符不为HLT，除PC增1外，其余控制线输出为0. （5）第4个时钟，操作。操作符为AND，ADD，XOR或LDA，读取相应地址的数据；操作符为JMP，将目的地址送给程序计数器；操作符为STO，输出累加器数据。（6）第5个时钟，若操作符为ANDD，ADD或者XORR，算术运算器完成相应的计算；操作符为LDA，就把数据通过算术运算器送给累加器；操作符为SKZ，先判断累加器的值是否为0，若为0，PC加1，否则保持原值；操作符为JMP，锁存目的地址；操作符为STO，将数据写入地址处。 (7)第6个时钟，空操作。 (8)第7个时钟，若操作符为SKZ且累加器为0，则PC值再加1，跳过一条指令，否则PC无变化。 // Description: RISC-CPU 主状态机 // ----------------------------------------------------------------------------- module machine ( input clk , // Clock input ena , // Clock Enable input zero , // Asynchronous reset active low input [2:0] opcode , // OP code output reg inc_pc , // output reg load_acc , // output reg load_pc , // output reg rd , // output reg wr , // output reg load_ir , // output reg datactl_ena , // output reg halt ); reg [2:0] state ; //parameter parameter HLT = 3'b000 , SKZ = 3'b001 , ADD = 3'b010 , ANDD = 3'b011 , XORR = 3'b100 , LDA = 3'b101 , STO = 3'b110 , JMP = 3'b111 ; always@(negedge clk) begin if(!ena) //收到复位信号rst，进行复位操作 begin state <= 3'b000; {inc_pc,load_acc,load_pc,rd} <= 4'b0000; {wr,load_ir,datactl_ena,halt} <= 4'b0000; end else ctl_cycle; end //------- task ctl_cycle ------- task ctl_cycle; begin casex(state) 3'b000: //load high 8bits in struction begin {inc_pc,load_acc,load_pc,rd} <= 4'b0001; {wr,load_ir,datactl_ena,halt} <= 4'b0100; state <= 3'b001; end 3'b001://pc increased by one then load low 8bits instruction begin {inc_pc,load_acc,load_pc,rd} <= 4'b1001; {wr,load_ir,datactl_ena,halt} <= 4'b0100; state <= 3'b010; end 3'b010: //idle begin {inc_pc,load_acc,load_pc,rd} <= 4'b0000; {wr,load_ir,datactl_ena,halt} <= 4'b0000; state <= 3'b011; end 3'b011: //next instruction address setup 分析指令开始点 begin if(opcode == HLT)//指令为暂停HLT begin {inc_pc,load_acc,load_pc,rd} <= 4'b1000; {wr,load_ir,datactl_ena,halt} <= 4'b0001; end else begin {inc_pc,load_acc,load_pc,rd} <= 4'b1000; {wr,load_ir,datactl_ena,halt} <= 4'b0000; end state <= 3'b100; end 3'b100: //fetch oprand begin if(opcode == JMP) begin {inc_pc,load_acc,load_pc,rd} <= 4'b0010; {wr,load_ir,datactl_ena,halt} <= 4'b0000; end else if(opcode == ADD || opcode == ANDD || opcode == XORR || opcode == LDA) begin {inc_pc,load_acc,load_pc,rd} <= 4'b0001; {wr,load_ir,datactl_ena,halt} <= 4'b0000; end else if(opcode == STO) begin {inc_pc,load_acc,load_pc,rd} <= 4'b0000; {wr,load_ir,datactl_ena,halt} <= 4'b0010; end else begin {inc_pc,load_acc,load_pc,rd} <= 4'b0000; {wr,load_ir,datactl_ena,halt} <= 4'b0000; end state <= 3'b101; end 3'b101://operation begin if(opcode == ADD || opcode == ANDD ||opcode ==XORR ||opcode == LDA)//过一个时钟后与累加器的内存进行运算 begin {inc_pc,load_acc,load_pc,rd} <= 4'b0101; {wr,load_ir,datactl_ena,halt} <= 4'b0000; end else if(opcode == SKZ && zero == 1)// & and && begin {inc_pc,load_acc,load_pc,rd} <= 4'b1000; {wr,load_ir,datactl_ena,halt} <= 4'b0000; end else if(opcode == JMP) begin {inc_pc,load_acc,load_pc,rd} <= 4'b1010; {wr,load_ir,datactl_ena,halt} <= 4'b0000; end else if(opcode == STO) begin//过一个时钟后吧wr变为1，写到RAM中 {inc_pc,load_acc,load_pc,rd} <= 4'b0000; {wr,load_ir,datactl_ena,halt} <= 4'b1010; end else begin {inc_pc,load_acc,load_pc,rd} <= 4'b0000; {wr,load_ir,datactl_ena,halt} <= 4'b0000; end state <= 3'b110; end 3'b110: begin if(opcode == STO) begin {inc_pc,load_acc,load_pc,rd} <= 4'b0000; {wr,load_ir,datactl_ena,halt} <= 4'b0010; end else if(opcode == ADD || opcode == ANDD || opcode == XORR || opcode == LDA) begin {inc_pc,load_acc,load_pc,rd} <= 4'b0001; {wr,load_ir,datactl_ena,halt} <= 4'b0000; end else begin {inc_pc,load_acc,load_pc,rd} <= 4'b0000; {wr,load_ir,datactl_ena,halt} <= 4'b0000; end state <= 3'b111; end 3'b111: begin if(opcode == SKZ && zero == 1) begin {inc_pc,load_acc,load_pc,rd} <= 4'b1000; {wr,load_ir,datactl_ena,halt} <= 4'b0000; end else begin {inc_pc,load_acc,load_pc,rd} <= 4'b0000; {wr,load_ir,datactl_ena,halt} <= 4'b0000; end state <= 3'b000; end default: begin {inc_pc,load_acc,load_pc,rd} <= 4'b0000; {wr,load_ir,datactl_ena,halt} <= 4'b0000; state <= 3'b000; end endcase end endtask endmodule 外围模块为了对RISC-CPU进行测试，需要对ROM、RAM和地址译码器进行设计。地址译码器模块说明：地址译码器用于产生选通信号，选通ROM或者RAM 1FFFH —— 1800H RAM（范围）：1_1xxx_xxxx_xxxx 17FFH —— 0000H ROM（范围）：0_xxxx_xxxx_xxxx+1_0xxx_xxxx_xxxx Verilog代码： // Description: RISC-CPU 地址译码器 // ----------------------------------------------------------------------------- module addr_decode ( input [12:0] addr , // Address output reg ram_sel , // Ram sel output reg rom_sel // Rom sel ); always@(addr)begin casex(addr) 13'b1_1xxx_xxxx_xxxx:{rom_sel,ram_sel} <= 2'b01; 13'b0_xxxx_xxxx_xxxx:{rom_sel,ram_sel} <= 2'b10; 13'b1_0xxx_xxxx_xxxx:{rom_sel,ram_sel} <= 2'b10; default: {rom_sel,ram_sel} <= 2'b00; endcase end endmodule RAM 模块说明： RAM用于存放临时数据，可读可写。 Verilog代码： // Description: RISC-CPU RAM模块 // ----------------------------------------------------------------------------- module ram ( input ena , // Enable input read , // read Enable input write , // write Enable inout wire [7:0] data , // data input [9:0] addr // address ); reg [7:0] ram [10'h3ff:0] ; assign data = (read && ena )? ram[addr]:8'h zz; always@(posedge write) begin ram[addr] <= data; end endmodule ROM 模块说明： RAM用于存放只读数据。 Verilog代码： // Description: RISC-CPU ROM模块 // ----------------------------------------------------------------------------- module rom ( input [12:0] addr , input read , input ena , output wire [7:0] data ); reg [7:0] memory [13'h1ff:0]; assign data = (read && ena)? memory[addr]:8'b zzzz_zzzz; endmodule 顶层模块模块图：图片图片 Verilog代码： // Description: RISC-CPU 顶层模块 // ----------------------------------------------------------------------------- //`include "clk_gen.v" //`include "accum.v" //`include "adr.v" //`include "alu.v" //`include "machine.v" //`include "counter.v" //`include "machinectl.v" //`iclude "machine.v" //`include "register.v" //`include "datactl.v" module RISC_CPU ( input clk , input reset , output wire rd , output wire wr , output wire halt , output wire fetch , //addr output wire [12:0] addr , output wire [12:0] ir_addr , output wire [12:0] pc_addr , inout wire [7:0] data , //op output wire [2:0] opcode ); wire [7:0] alu_out ; wire [7:0] accum ; wire zero ; wire inc_pc ; wire load_acc ; wire load_pc ; wire load_ir ; wire data_ena ; wire contr_ena ; wire alu_ena ; //inst clk_gen mclk_gen( .clk (clk ), .reset (reset ), .fetch (fetch ), .alu_ena (alu_ena ) ); register m_register( .data (data ), .ena (load_ir ), .rst (reset ), .clk (clk ), .opc_iraddr ({opcode,ir_addr} ) ); accum m_accum( .data (alu_out ), .ena (load_acc ), .clk (clk ), .rst (reset ), .accum (accum ) ); alu m_alu( .data (data ), .accum (accum ), .clk (clk ), .alu_ena (alu_ena ), .opcode (opcode ), .alu_out (alu_out ), .zero (zero ) ); machinectl m_machinectl( .clk (clk ), .rst (reset ), .fetch (fetch ), .ena (contr_ena ) ); machine m_machine( .inc_pc (inc_pc ), .load_acc (load_acc ), .load_pc (load_pc ), .rd (rd ), .wr (wr ), .load_ir (load_ir ), .clk (clk ), .datactl_ena(data_ena ), .halt (halt ), .zero (zero ), .ena (contr_ena ), .opcode (opcode ) ); datactl m_datactl( .in (alu_out ), .data_ena (data_ena ), .data (data ) ); adr m_adr( .fetch (fetch ), .ir_addr (ir_addr ), .pc_addr (pc_addr ), .addr (addr ) ); counter m_counter( .clock (inc_pc ), .rst (reset ), .ir_addr (ir_addr ), .load (load_pc ), .pc_addr (pc_addr ) ); endmodule Testbench Testbench包含三个测试程序,这个部分不能综合。 Test1程序 TEST1程序用于验证RISC-CPU的逻辑功能，根据汇编语言由人工编译的。若各条指令正确，应该在地址2E(hex)处，在执行HLT时刻停止。若程序在任何其他位置停止，则必有一条指令运行错误，可以按照注释找到错误的指令。 test1汇编程序：(.pro文件/存放于ROM) //机器码-地址-汇编助记符-注释 @00 //address statement 111_0000 //00 BEGIN: JMP TST_JMP 0011_1100 000_0000 //02 HLT //JMP did not work 0000_0000 000_00000 //04 HLT //JMP did not load PC skiped 0000_0000 101_1100 //06 JMP_OK: LDA DATA 0000_0000 001_00000 //08 SKZ 0000_0000 000_0000 //0a HLT 0000_0000 101_11000 //0C LDA DATA_2 0000_0001 001_00000 //0E SKZ 0000_0000 111_0000 //10 JMP SKZ_OK 001_0100 000_0000 //12 HLT 0000_0000 110_11000 //14 SKZ_OK: STO TEMP 0000_0010 101_11000 //16 LDA DATA_1 0000_0000 110_11000 //18 STO TEMP 0000_0010 101_11000 //1A LDA TEMP 0000_0010 001_00000 //1C SKZ 0000_0000 000_00000 //1E HLT 0000_0000 100_11000 //20 XOR DATA_2 0000_0001 001_00000 //22 SKZ 0000_0000 111_00000 //24 JMP XOR_OK 0010_1000 000_00000 //26 HLT 0000_0000 100_11000 //28 XOR_OK XOR DATA_2 0000_0001 001_00000 //2A SKZ 0000_0000 000_00000 //2C HLT 0000_0000 000_0000 //2E END 0000_0000 111_00000 //30 JMP BEGIN 0000_0000 @3c 111_00000 //3c TST_JMP IMR OK 0000_0110 000_00000 //3E HLT test1数据文件：（.dat/存放于RAM） /----------------------------------- @00 ///address statement at RAM 00000000 //1800 DATA_1 11111111 //1801 DATA_2 10101010 //1082 TEMPTest2程序 TEST1程序用于验证RISC-CPU的逻辑功能，根据汇编语言由人工编译的。这个程序是用来测试RISC-CPU的高级指令集，若执行正确，应在地址20（hex）处在执行HLT时停止。 test2汇编程序： @00 101_11000 //00 BEGIN 0000_0001 011_11000 //02 AND DATA_3 0000_0010 100_11000 //04 XOR DATA_2 0000_0001 001_00000 //06 SKZ 0000_0000 000_00000 //08 HLT 0000_0000 010_11000 //0A ADD DATA_1 0000_0000 001_00000 //0C SKZ 0000_0000 111_00000 //0E JMP ADD_OK 0001_0010 111_00000 //10 HLT 0000_0000 100_11000 //12 ADD_OK XOR DATA_3 0000_0010 010_11000 //14 ADD DATA_1 0000_0000 110_11000 //16 STO TEMP 0000_0011 101_11000 //18 LDA DATA_1 0000_0000 010_11000 //1A ADD TEMP 0000_0001 001_00000 //1C SKZ 0000_0000 000_00000 //1E HLT 0000_0000 000_00000 //END HLT 0000_0000 111_00000 //JMP BEGIN 0000_0000test2数据文件： @00 00000001 //1800 DATA_1 10101010 //1801 DATA_2 11111111 //1802 DATA_3 00000000 //1803 TEMPTest3程序 TEST3程序是一个计算0~144的斐波那契数列的程序，用来验证CPU整体功能。 test3汇编程序： @00 101_11000 //00 LOOP:LDA FN2 0000_0001 110_11000 //02 STO TEMP 0000_0010 010_11000 //04 ADD FN1 0000_0000 110_11000 //06 STO FN2 0000_0001 101_11000 //08 VLDA TEMP 0000_0010 110_11000 //0A STO FN1 0000_0000 100_11000 //0C XOR LIMIT 0000_0011 001_00000 //0E SKZ 0000_0000 111_00000 //10 JMP LOOP 0000_0000 000_00000 //12 DONE HLT 0000_0000test3数据文件： @00 00000001 //1800 FN1 00000000 //1801 FN2 00000000 //1802 TEMP 10010000 //1803 LIMIT完整的testbench Verilog代码： // Description: RISC-CPU 测试程序 // ----------------------------------------------------------------------------- `include "RISC_CPU.v" `include "ram.v" `include "rom.v" `include "addr_decode.v" `timescale 1ns/1ns `define PERIOD 100 // matches clk_gen.v module cputop_tb; reg [( 3 * 8 ): 0 ] mnemonic; // array that holds 3 8 bits ASCII characters reg [ 12 : 0 ] PC_addr, IR_addr; reg reset_req, clock; wire [ 12 : 0 ] ir_addr, pc_addr; // for post simulation. wire [ 12 : 0 ] addr; wire [ 7 : 0 ] data; wire [ 2 : 0 ] opcode; // for post simulation. wire fetch; // for post simulation. wire rd, wr, halt, ram_sel, rom_sel; integer test; //-----------------DIGITAL LOGIC---------------------- RISC_CPU t_cpu (.clk( clock ),.reset( reset_req ),.halt( halt ),.rd( rd ),.wr( wr ),.addr( addr ),.data( data ),.opcode( opcode ),.fetch( fetch ),.ir_addr( ir_addr ),.pc_addr( pc_addr )); ram t_ram (.addr ( addr [ 9 : 0 ]),.read ( rd ),.write ( wr ),.ena ( ram_sel ),.data ( data )); rom t_rom (.addr ( addr ),.read ( rd ), .ena ( rom_sel ),.data ( data )); addr_decode t_addr_decoder (.addr( addr ),.ram_sel( ram_sel ),.rom_sel( rom_sel )); //-------------------SIMULATION------------------------- initial begin clock = 0; // display time in nanoseconds $timeformat ( -9, 1, "ns", 12 ); display_debug_message; sys_reset; test1; $stop; test2; $stop; test3; $finish; // simulation is finished here. end // initial task display_debug_message; begin $display ("\n************************************************" ); $display ( "* THE FOLLOWING DEBUG TASK ARE AVAILABLE: *" ); $display ( "* \"test1;\" to load the 1st diagnostic program. *"); $display ( "* \"test2;\" to load the 2nd diagnostic program. *"); $display ( "* \"test3;\" to load the Fibonacci program. *"); $display ( "************************************************\n"); end endtask // display_debug_message task test1; begin test = 0; disable MONITOR; $readmemb ("test1.pro", t_rom.memory ); $display ("rom loaded successfully!"); $readmemb ("test1.dat", t_ram.ram ); $display ("ram loaded successfully!"); #1 test = 1; #14800; sys_reset; end endtask // test1 task test2; begin test = 0; disable MONITOR; $readmemb ("test2.pro", t_rom.memory ); $display ("rom loaded successfully!"); $readmemb ("test2.dat", t_ram.ram ); $display ("ram loaded successfully!"); #1 test = 2; #11600; sys_reset; end endtask // test2 task test3; begin test = 0; disable MONITOR; $readmemb ("test3.pro", t_rom.memory ); $display ("rom loaded successfully!"); $readmemb ("test3.dat", t_ram.ram ); $display ("ram loaded successfully!"); #1 test = 3; #94000; sys_reset; end endtask // test1 task sys_reset; begin reset_req = 0; #( `PERIOD * 0.7 ) reset_req = 1; #( 1.5 * `PERIOD ) reset_req = 0; end endtask // sys_reset //--------------------------MONITOR-------------------------------- always@( test ) begin: MONITOR case( test ) 1: begin // display results when running test 1 $display("\n*** RUNNING CPU test 1 - The Basic CPU Diagnostic Program ***"); $display("\n TIME PC INSTR ADDR DATA "); $display(" ------ ---- ------- ------ ------ "); while( test == 1 )@( t_cpu.pc_addr ) begin // fixed if(( t_cpu.pc_addr % 2 == 1 )&&( t_cpu.fetch == 1 )) begin // fixed #60 PC_addr <= t_cpu.pc_addr - 1; IR_addr <= t_cpu.ir_addr; #340 $strobe("%t %h %s %h %h", $time, PC_addr, mnemonic, IR_addr, data ); // Here data has been changed t_cpu.m_register.data end // if t_cpu.pc_addr % 2 == 1 && t_cpu.fetch == 1 end // while test == 1 @ t_cpu.pc_addr end 2: begin // display results when running test 2 $display("\n*** RUNNING CPU test 2 - The Basic CPU Diagnostic Program ***"); $display("\n TIME PC INSTR ADDR DATA "); $display(" ------ ---- ------- ------ ------ "); while( test == 2 )@( t_cpu.pc_addr ) begin // fixed if(( t_cpu.pc_addr % 2 == 1 )&&( t_cpu.fetch == 1 )) begin // fixed #60 PC_addr <= t_cpu.pc_addr - 1; IR_addr <= t_cpu.ir_addr; #340 $strobe("%t %h %s %h %h", $time, PC_addr, mnemonic, IR_addr, data ); // Here data has been changed t_cpu.m_register.data end // if t_cpu.pc_addr % 2 == 1 && t_cpu.fetch == 1 end // while test == 2 @ t_cpu.pc_addr end 3: begin // display results when running test 3 $display("\n*** RUNNING CPU test 3 - An Executable Program **************"); $display("***** This program should calculate the fibonacci *************"); $display("\n TIME FIBONACCI NUMBER "); $display(" ------ -----------------_ "); while( test == 3 ) begin wait( t_cpu.opcode == 3'h 1 ) // display Fib. No. at end of program loop $strobe("%t %d", $time, t_ram.ram [ 10'h 2 ]); wait( t_cpu.opcode != 3'h 1 ); end // while test == 3 end endcase // test end // MONITOR: always@ test //-------------------------HALT------------------------------- always@( posedge halt ) begin // STOP when HALT intruction decoded #500 $display("\n******************************************"); $display( "** A HALT INSTRUCTION WAS PROCESSED !!! **"); $display( "******************************************"); end // always@ posedge halt //-----------------------CLOCK & MNEMONIC------------------------- always#(`PERIOD / 2 ) clock = ~ clock; always@( t_cpu.opcode ) begin // get an ASCII mnemonic for each opcode case( t_cpu.opcode ) 3'b 000 : mnemonic = "HLT"; 3'b 001 : mnemonic = "SKZ"; 3'b 010 : mnemonic = "ADD"; 3'b 011 : mnemonic = "AND"; 3'b 100 : mnemonic = "XOR"; 3'b 101 : mnemonic = "LDA"; 3'b 110 : mnemonic = "STO"; 3'b 111 : mnemonic = "JMP"; default : mnemonic = "???"; endcase end endmodule $ readmemb ( "test1. pro" ,t_ rom. . memory ); $ readmemb ( "testl. dat",t_ ram_ . ram); 即可把编译好的汇编机器码装人虚拟ROM,把需要参加运算的数据装人虚拟RAM就可以开始仿真。上面语句中的第一项为打开的文件名,后一项为系统层次管理下的ROM模块和RAM模块中的存储器memory和ram。源代码&脚本见文章末尾前仿真结果 test1 图片 test2 图片 test3 图片图片 DC后仿真采用SMIC180工艺在典型环境下进行测试时序报告：图片面积报告：图片功耗报告：图片综合电路图：图片图片图片总结该项目更加偏向于教学练习，CPU也是数字IC的重要研究方向，对此感兴趣的同学可以找点论文和开源资料进行学习。可以进一步优化如流水线、运算单元，扩展成SOC系统等。源代码&脚本

FPGA&ASIC IP&SOC设计 # ASIC/FPGA # SOC设计

刘航宇 3年前
15 2,182 7
使用Verilog实现与仿真AMBA--AHB总线协议（三） 1、AHB从机 AHB从机应答来自系统主主机发起的传输。从机使用从译码器输出的 HSELx 信号来决定它什么时候作应答。其它传输需要的信号，如地址与控制信息由主机产生。下图为一个AHB从机的接口框图：图片下面是一个AHB接口的SRAM控制器的程序： //------------------------------------------------------------------------------ // File : ahb_sram.v // Editor : VSCode, Tab Size(4) // Description : Top Module of AHB SRAM Controller. // //------------------------------------------------------------------------------ `timescale 1ns / 1ps module ahb_sram #( parameter SYNC_RESET = 1, parameter AHB_DWIDTH = 32, parameter AHB_AWIDTH = 32, parameter SIZE_IN_BYTES = 2048, parameter ADD_WIDTH = $clog2(SIZE_IN_BYTES) ) ( //---------------------------------- // IO Declarations //---------------------------------- // Inputs input HCLK, input HRESETN, input HSEL, input HREADYIN, input [1:0] HTRANS, input [2:0] HBURST, input [2:0] HSIZE, input [AHB_DWIDTH-1:0] HWDATA, input [AHB_AWIDTH-1:0] HADDR, input HWRITE, // Outputs output [AHB_DWIDTH-1:0] HRDATA, output [1:0] HRESP, output HREADYOUT ); //---------------------------------- // Variable Declarations //---------------------------------- wire [ADD_WIDTH-1:0] HADDR_cal; wire [2:0] ahbsram_size; wire [ADD_WIDTH-1:0] ahbsram_addr; wire [31:0] ahbsram_wdata; wire ahbsram_write; wire [31:0] sramahb_rdata; wire sramahb_ack; //---------------------------------- // Start of Main Code //---------------------------------- assign HADDR_cal = HADDR[ADD_WIDTH-1:0]; // Instantiations ahb_sram_if #( .AHB_DWIDTH (AHB_DWIDTH), .AHB_AWIDTH (AHB_AWIDTH), .ADD_WIDTH (ADD_WIDTH), .SYNC_RESET (SYNC_RESET) ) u_ahb_sram_if ( .HCLK (HCLK), .HRESETN (HRESETN), .HSEL (HSEL), .HTRANS (HTRANS), .HBURST (HBURST), .HWRITE (HWRITE), .HWDATA (HWDATA), .HSIZE (HSIZE), .HADDR (HADDR_cal), .HREADYIN (HREADYIN), // From SRAM Control signals .sramahb_ack (sramahb_ack), .sramahb_rdata (sramahb_rdata), // Outputs .HREADYOUT (HREADYOUT), .HRESP (HRESP), // To SRAM Control signals .ahbsram_req (ahbsram_req), .ahbsram_write (ahbsram_write), .ahbsram_wdata (ahbsram_wdata), .ahbsram_size (ahbsram_size), .ahbsram_addr (ahbsram_addr), .HRDATA (HRDATA) ); sram_ctrl_if #( .ADD_WIDTH (ADD_WIDTH), .SYNC_RESET (SYNC_RESET) ) u_sram_ctrl_if ( .HCLK (HCLK), .HRESETN (HRESETN), // From AHB Interface signals .ahbsram_req (ahbsram_req), .ahbsram_write (ahbsram_write), .ahbsram_wdata (ahbsram_wdata), .ahbsram_size (ahbsram_size), .ahbsram_addr (ahbsram_addr), // Outputs // To AHB Interface signals .sramahb_ack (sramahb_ack), .sramahb_rdata (sramahb_rdata) ); endmodule //------------------------------------------------------------------------------ // File : ahb_sram_if.v // Editor : VSCode, Tab Size(4) // Description : // //------------------------------------------------------------------------------ `timescale 1ns / 1ps module ahb_sram_if #( parameter AHB_DWIDTH = 32, parameter AHB_AWIDTH = 32, parameter ADD_WIDTH = 11, parameter SYNC_RESET = 0 ) ( //---------------------------------- // IO Declarations //---------------------------------- // Inputs input HCLK, input HRESETN, input HSEL, input HREADYIN, input [1:0] HTRANS, input [2:0] HBURST, input [2:0] HSIZE, input [ADD_WIDTH-1:0] HADDR, input [AHB_DWIDTH-1:0] HWDATA, input HWRITE, input sramahb_ack, input [AHB_DWIDTH-1:0] sramahb_rdata, // Outputs output HREADYOUT, output [1:0] HRESP, output reg [AHB_DWIDTH-1:0] HRDATA, output ahbsram_req, output ahbsram_write, output [AHB_AWIDTH-1:0] ahbsram_wdata, output [2:0] ahbsram_size, output [ADD_WIDTH-1:0] ahbsram_addr ); //---------------------------------- // Local Parameter Declarations //---------------------------------- // State Machine parameters localparam IDLE = 2'b00; localparam AHB_WR = 2'b01; localparam AHB_RD = 2'b10; parameter RESP_OKAY = 2'b00; parameter RESP_ERROR = 2'b01; // AHB HTRANS definition parameter TRN_IDLE = 2'b00; parameter TRN_BUSY = 2'b01; parameter TRN_SEQ = 2'b11; parameter TRN_NONSEQ = 2'b10; parameter SINGLE = 3'b000; parameter INCR = 3'b001; parameter WRAP4 = 3'b010; parameter INCR4 = 3'b011; parameter WRAP8 = 3'b100; parameter INCR8 = 3'b101; parameter WRAP16 = 3'b110; parameter INCR16 = 3'b111; //---------------------------------- // Variable Declarations //---------------------------------- reg [1:0] HTRANS_d; reg [2:0] HBURST_d; reg [2:0] HSIZE_d; reg [ADD_WIDTH-1:0] HADDR_d; reg [AHB_DWIDTH-1:0] HWDATA_d; reg HWRITE_d; reg HSEL_d; reg HREADYIN_d; reg [1:0] ahbcurr_state; reg [1:0] ahbnext_state; reg latchahbcmd; reg ahbsram_req_int; reg ahbsram_req_d1; reg [AHB_DWIDTH-1:0] HWDATA_cal; reg [4:0] burst_count; reg [4:0] burst_count_reg; reg [4:0] count; wire aresetn; wire sresetn; //---------------------------------- // Start of Main Code //---------------------------------- assign aresetn = (SYNC_RESET==1) ? 1'b1 : HRESETN; assign sresetn = (SYNC_RESET==1) ? HRESETN : 1'b1; // Generation of valid AHB Command which triggers the AHB Slave State Machine assign validahbcmd = HREADYIN & HSEL & (HTRANS == TRN_NONSEQ); // Generation of HRESP assign HRESP = RESP_OKAY; always @(*) begin HWDATA_cal = HWDATA; end // Latch all the AHB signals always @(posedge HCLK or negedge aresetn) begin if ((aresetn == 1'b0) || (sresetn == 1'b0)) begin HADDR_d <= {20{1'b0}}; HWDATA_d <= {32{1'b0}}; HTRANS_d <= 2'b00; HSIZE_d <= 2'b00; HBURST_d <= 3'b000; HWRITE_d <= 1'b0; HSEL_d <= 1'b0; HREADYIN_d <= 1'b0; end else if (HREADYIN == 1'b1 & HSEL == 1'b1 & HREADYOUT == 1'b1) begin HADDR_d <= HADDR; HTRANS_d <= HTRANS; HSIZE_d <= HSIZE; HBURST_d <= HBURST; HWRITE_d <= HWRITE; HWDATA_d <= HWDATA_cal; HSEL_d <= HSEL; HREADYIN_d <= HREADYIN; end end // Current State generation always @(posedge HCLK or negedge aresetn) begin if ((aresetn == 1'b0) || (sresetn == 1'b0)) begin ahbcurr_state <= IDLE; end else begin ahbcurr_state <= ahbnext_state; end end // Next State and output decoder logic always @(*) begin latchahbcmd = 1'b0; ahbsram_req_int = 1'b0; ahbnext_state = ahbcurr_state; case (ahbcurr_state) IDLE : begin if (HREADYIN == 1'b1 && HSEL == 1'b1 && ((HTRANS == TRN_NONSEQ) || HTRANS == TRN_SEQ)) begin latchahbcmd = 1'b1; if (HWRITE == 1'b1) begin ahbnext_state = AHB_WR; end else begin ahbnext_state = AHB_RD; end end else begin ahbnext_state = IDLE; end end AHB_WR : begin latchahbcmd = 1'b0; ahbsram_req_int = 1'b1; if (sramahb_ack == 1'b1) begin if (count == burst_count_reg) begin ahbnext_state = IDLE; end else begin ahbsram_req_int = 1'b0; end end end AHB_RD : begin latchahbcmd = 1'b0; ahbsram_req_int = 1'b1; if (sramahb_ack == 1'b1) begin ahbnext_state = IDLE; end end default : begin ahbnext_state = IDLE; end endcase end // LOGIC FOR BURST COUNT always @(*) begin burst_count = burst_count_reg; if (HSEL == 1'b1 && HTRANS == TRN_NONSEQ && HREADYIN == 1'b1 && HREADYOUT == 1'b1) begin case (HBURST) SINGLE : burst_count = 5'b00001; WRAP4,INCR4 : burst_count = 5'b00100; WRAP8,INCR8 : burst_count = 5'b01000; WRAP16,INCR16 : burst_count = 5'b10000; default : burst_count = 4'b0001; endcase end end always @(posedge HCLK or negedge aresetn) begin if ((aresetn == 1'b0) || (sresetn == 1'b0)) begin burst_count_reg <= 'h0; end else begin burst_count_reg <= burst_count; end end always @(posedge HCLK or negedge aresetn) begin if ((aresetn == 1'b0) || (sresetn == 1'b0)) begin count <= 5'h0; end else begin if (count == burst_count_reg) begin count <= 5'h0; end else if (ahbsram_req == 1'b1) begin count <= count + 1'b1; end else begin count <= count; end end end assign HREADYOUT = !ahbsram_req_int; // Generation of signals required for SRAM assign ahbsram_write = ahbsram_req ? HWRITE_d : 1'b0; assign ahbsram_wdata = HWDATA; assign ahbsram_addr = ahbsram_req ? HADDR_d : HADDR_d; assign ahbsram_size = ahbsram_req ? HSIZE_d : HSIZE_d; always @(posedge HCLK or negedge aresetn) begin if ((aresetn == 1'b0) || (sresetn == 1'b0)) begin ahbsram_req_d1 <= 1'b0; end else begin ahbsram_req_d1 <= ahbsram_req_int; end end // Generate the request to the SRAM contol logic when there is AHB read or write request assign ahbsram_req = ahbsram_req_int & !ahbsram_req_d1; // HRDATA generation always @(*) begin if (HREADYOUT && HREADYIN) begin HRDATA = sramahb_rdata; end else begin HRDATA = sramahb_rdata; end end endmodule //------------------------------------------------------------------------------ // File : sram_ctrl_if.v // Editor : VSCode, Tab Size(4) // Description : // //------------------------------------------------------------------------------ `timescale 1ns / 1ps module sram_ctrl_if #( parameter AHB_DWIDTH = 32, parameter ADD_WIDTH = 11, parameter SYNC_RESET = 0 ) ( //---------------------------------- // IO Declarations //---------------------------------- // Inputs input HCLK, input HRESETN, input ahbsram_req, input ahbsram_write, input [2:0] ahbsram_size, input [ADD_WIDTH-1:0] ahbsram_addr, input [AHB_DWIDTH-1:0] ahbsram_wdata, // Outputs output sramahb_ack, output reg [AHB_DWIDTH-1: 0] sramahb_rdata ); //---------------------------------- // Local Parameter Declarations //---------------------------------- // State Machine parameters localparam S_IDLE = 2'b00; localparam S_WR = 2'b01; localparam S_RD = 2'b10; //---------------------------------- // Variable Declarations //---------------------------------- reg [3:0] sram_wen_mem; reg [1:0] sramcurr_state; reg [1:0] sramnext_state; reg sram_wen; reg sram_ren; reg sramahb_ack_int; reg sram_ren_d; reg sram_done; wire [AHB_DWIDTH-1:0] ram_rdata; wire aresetn; wire sresetn; //---------------------------------- // Start of Main Code //---------------------------------- assign aresetn = (SYNC_RESET == 1) ? 1'b1 : HRESETN; assign sresetn = (SYNC_RESET == 1) ? HRESETN : 1'b1; // Current State generation always @(posedge HCLK or negedge aresetn) begin if ((aresetn == 1'b0) || (sresetn == 1'b0)) begin sramcurr_state <= S_IDLE; end else begin sramcurr_state <= sramnext_state; end end // Next State and output decoder logic always @(*) begin sramahb_ack_int = 1'b0; sram_wen = 1'b0; sram_ren = 1'b0; sramnext_state = sramcurr_state; case (sramcurr_state) S_IDLE : begin if (ahbsram_req == 1'b1) begin if (ahbsram_write == 1'b1) begin sramnext_state = S_WR; sram_wen = 1'b1; end else begin sram_ren = 1'b1; sramnext_state = S_RD; end end end S_WR : begin if (sram_done == 1'b1) begin sramnext_state = S_IDLE; sramahb_ack_int = 1'b1; end end S_RD : begin if (sram_done == 1'b1) begin sramnext_state = S_IDLE; sramahb_ack_int = 1'b1; end end default : begin sramnext_state = S_IDLE; end endcase end always @(*) begin sram_wen_mem = 4'b0000; if (ahbsram_size == 3'b010) begin sram_wen_mem = {4{sram_wen}}; end else if (ahbsram_size == 3'b001) begin case (ahbsram_addr[1]) 1'b0 : begin sram_wen_mem[0] = sram_wen; sram_wen_mem[1] = sram_wen; sram_wen_mem[2] = 1'b0; sram_wen_mem[3] = 1'b0; end 1'b1 : begin sram_wen_mem[0] = 1'b0; sram_wen_mem[1] = 1'b0; sram_wen_mem[2] = sram_wen; sram_wen_mem[3] = sram_wen; end endcase end else if (ahbsram_size == 3'b000) begin case (ahbsram_addr[1:0]) 2'b00 : begin sram_wen_mem[0] = sram_wen; sram_wen_mem[1] = 1'b0; sram_wen_mem[2] = 1'b0; sram_wen_mem[3] = 1'b0; end 2'b01 : begin sram_wen_mem[0] = 1'b0; sram_wen_mem[1] = sram_wen; sram_wen_mem[2] = 1'b0; sram_wen_mem[3] = 1'b0; end 2'b10 : begin sram_wen_mem[0] = 1'b0; sram_wen_mem[1] = 1'b0; sram_wen_mem[2] = sram_wen; sram_wen_mem[3] = 1'b0; end 2'b11 : begin sram_wen_mem[0] = 1'b0; sram_wen_mem[1] = 1'b0; sram_wen_mem[2] = 1'b0; sram_wen_mem[3] = sram_wen; end endcase end else begin sram_wen_mem = {4{sram_wen}}; end end // SRAM Instantiations sram_model #( .SYNC_RESET (SYNC_RESET), .ADDR_WIDTH (ADD_WIDTH) ) u_sram_model ( .writedata (ahbsram_wdata), .readdata (ram_rdata[31:0]), .wren (sram_wen_mem), .rden (sram_ren), .writeaddr (ahbsram_addr[ADD_WIDTH-1:2]), .readaddr (ahbsram_addr[ADD_WIDTH-1:2]), .clk (HCLK), .resetn (HRESETN) ); always @(posedge HCLK or negedge aresetn) begin if ((aresetn == 1'b0) || (sresetn == 1'b0)) begin sramahb_rdata <= 32'h0; end else if (sram_ren_d == 1'b1) begin sramahb_rdata <= ram_rdata; end else begin sramahb_rdata <= sramahb_rdata; end end always @(posedge HCLK or negedge aresetn) begin if ((aresetn == 1'b0) || (sresetn == 1'b0)) begin sram_ren_d <= 32'h0; end else begin sram_ren_d <= sram_ren; end end // Generate the SRAM done when the SRAM wren/rden is done always @(posedge HCLK or negedge aresetn) begin if ((aresetn == 1'b0) || (sresetn == 1'b0)) begin sram_done <= 1'b0; end else if (sram_wen || sram_ren) begin sram_done <= 1'b1; end else begin sram_done <= 1'b0; end end // Generate the SRAM ack assign sramahb_ack = sramahb_ack_int; endmodule //------------------------------------------------------------------------------ // File : sram_model.v // Editor : GVIM, Tab Size(4) // Description : FPGA Block Ram/Onchip SRAM. // //------------------------------------------------------------------------------ `timescale 1ns / 1ps module sram_model #( parameter SYNC_RESET = 0, parameter ADDR_WIDTH = 16 ) ( //---------------------------------- // IO Declarations //---------------------------------- input [31:0] writedata, output [31:0] readdata, input [3:0] wren, input rden, input [ADDR_WIDTH-1:2] writeaddr, input [ADDR_WIDTH-1:2] readaddr, input clk, input resetn ); //---------------------------------- //--Local Parameter Declarations //---------------------------------- localparam AWT = ((1<<(ADDR_WIDTH-2))-1); //---------------------------------- // Variable Declarations //---------------------------------- reg [7:0] bram0[AWT:0]; reg [7:0] bram1[AWT:0]; reg [7:0] bram2[AWT:0]; reg [7:0] bram3[AWT:0]; reg [ADDR_WIDTH-3:0] addr_q1; reg rden_r = 1'b0; wire [31:0] readdata_i; wire aresetn; wire sresetn; //---------------------------------- // Start of Main Code //---------------------------------- assign aresetn = (SYNC_RESET == 1) ? 1'b1 : resetn; assign sresetn = (SYNC_RESET == 1) ? resetn : 1'b1; always @(posedge clk) begin rden_r <= rden; end // Infer Block RAM always @(posedge clk) begin if (wren[0]) bram0[writeaddr] <= writedata[7:0]; if (wren[1]) bram1[writeaddr] <= writedata[15:8]; if (wren[2]) bram2[writeaddr] <= writedata[23:16]; if (wren[3]) bram3[writeaddr] <= writedata[31:24]; end always @(posedge clk) begin addr_q1 <= readaddr[ADDR_WIDTH-1:2]; end assign readdata_i = {bram3[addr_q1],bram2[addr_q1],bram1[addr_q1],bram0[addr_q1]}; assign readdata = rden_r ? readdata_i : {32{1'b0}}; endmodule下面是测试用例代码： //------------------------------------------------------------------------------ // File : top_tb.v // Editor : VSCode, Tab Size(4) // Description : Testbench of AHB SRAM Controller. // //------------------------------------------------------------------------------ `timescale 1ns / 1ps module top_tb(); //---------------------------------- // Local Parameter Declarations //---------------------------------- localparam AHB_CLK_PERIOD = 5; // Assuming AHB CLK to be 100MHz localparam SIZE_IN_BYTES =2048; //---------------------------------- // Variable Declarations //---------------------------------- reg HCLK = 0; wire HWRITE; wire [1:0] HTRANS; wire [2:0] HSIZE; wire [2:0] HBURST; wire HREADYIN; wire [31:0] HADDR; wire [31:0] HWDATA; wire HREADYOUT; wire [1:0] HRESP; wire [31:0] HRDATA; reg HRESETn; //---------------------------------- // Start of Main Code //---------------------------------- //----------------------------------------------------------------------- // Generate HCLK //----------------------------------------------------------------------- always #AHB_CLK_PERIOD HCLK <= ~HCLK; //----------------------------------------------------------------------- // Generate HRESETn //----------------------------------------------------------------------- initial begin HRESETn = 1'b0; repeat(5) @(posedge HCLK); HRESETn = 1'b1; end ahb_master #( .START_ADDR (32'h0), .DEPTH_IN_BYTES (SIZE_IN_BYTES) ) u_ahb_master ( .HRESETn (HRESETn), .HCLK (HCLK), .HADDR (HADDR), .HTRANS (HTRANS), .HWRITE (HWRITE), .HSIZE (HSIZE), .HBURST (HBURST), .HWDATA (HWDATA), .HRDATA (HRDATA), .HRESP (HRESP), .HREADY (HREADYOUT) ); ahb_sram # ( .AHB_AWIDTH (32), .AHB_DWIDTH (32), .SIZE_IN_BYTES (SIZE_IN_BYTES), .SYNC_RESET (1) ) u_ahb_sram ( .HCLK (HCLK), .HRESETN (HRESETn), .HSEL (1'b1), .HWRITE (HWRITE), .HADDR (HADDR), .HWDATA (HWDATA), .HRDATA (HRDATA), .HSIZE (HSIZE), .HTRANS (HTRANS), .HBURST (HBURST), .HRESP (HRESP), .HREADYIN (1'b1), .HREADYOUT (HREADYOUT) ); `ifdef VCS initial begin $fsdbDumpfile("top_tb.fsdb"); $fsdbDumpvars; end initial begin `ifdef DUMP_VPD $vcdpluson(); `endif end `endif endmodule这个模块主要是产生了时钟和复位信号，例化了待测模块，以及一个AHB Master的功能模型。具体见下面的代码： //------------------------------------------------------------------------------ // File : ahb_master.v // Editor : VSCode, Tab Size(4) // Description : AHB Master Simulation Model. // //------------------------------------------------------------------------------ `timescale 1ns / 1ps `define SINGLE_TEST `define BURST_TEST module ahb_master #( //---------------------------------- // Paramter Declarations //---------------------------------- parameter START_ADDR = 0, parameter DEPTH_IN_BYTES = 32'h100, parameter END_ADDR = START_ADDR+DEPTH_IN_BYTES-1 ) ( //---------------------------------- // IO Declarations //---------------------------------- input wire HRESETn, input wire HCLK, output reg [31:0] HADDR, output reg [1:0] HTRANS, output reg HWRITE, output reg [2:0] HSIZE, output reg [2:0] HBURST, output reg [31:0] HWDATA, input wire [31:0] HRDATA, input wire [1:0] HRESP, input wire HREADY ); //---------------------------------- // Variable Declarations //---------------------------------- reg [31:0] data_burst[0:1023]; //---------------------------------- // Start of Main Code //---------------------------------- initial begin HADDR = 0; HTRANS = 0; HWRITE = 0; HSIZE = 0; HBURST = 0; HWDATA = 0; while(HRESETn === 1'bx) @(posedge HCLK); while(HRESETn === 1'b1) @(posedge HCLK); while(HRESETn === 1'b0) @(posedge HCLK); `ifdef SINGLE_TEST repeat(3) @(posedge HCLK); memory_test(START_ADDR, END_ADDR, 1); memory_test(START_ADDR, END_ADDR, 2); memory_test(START_ADDR, END_ADDR, 4); `endif `ifdef BURST_TEST repeat(5) @(posedge HCLK); memory_test_burst(START_ADDR, END_ADDR, 1); memory_test_burst(START_ADDR, END_ADDR, 2); memory_test_burst(START_ADDR, END_ADDR, 4); memory_test_burst(START_ADDR, END_ADDR, 6); memory_test_burst(START_ADDR, END_ADDR, 8); memory_test_burst(START_ADDR, END_ADDR, 10); memory_test_burst(START_ADDR, END_ADDR, 16); memory_test_burst(START_ADDR, END_ADDR, 32); memory_test_burst(START_ADDR, END_ADDR, 64); memory_test_burst(START_ADDR, END_ADDR, 128); memory_test_burst(START_ADDR, END_ADDR, 255); repeat(5) @(posedge HCLK); `endif $finish(2); end //----------------------------------------------------------------------- // Single transfer test //----------------------------------------------------------------------- task memory_test; input [31:0] start; // start address input [31:0] finish; // end address input [2:0] size; // data size: 1, 2, 4 integer i; integer error; reg [31:0] data; reg [31:0] gen; reg [31:0] got; reg [31:0] reposit[START_ADDR:END_ADDR]; begin $display("%m: read-after-write test with %d-byte access", size); error = 0; gen = $random(7); for (i = start; i < (finish-size+1); i = i + size) begin gen = $random & ~32'b0; data = align(i, gen, size); ahb_write(i, size, data); ahb_read(i, size, got); got = align(i, got, size); if (got !== data) begin $display("[%10d] %m A:%x D:%x, but %x expected", $time, i, got, data); error = error + 1; end end if (error == 0) $display("[%10d] %m OK: from %x to %x", $time, start, finish); $display("%m read-all-after-write-all with %d-byte access", size); error = 0; gen = $random(1); for (i = start; i < (finish-size+1); i = i + size) begin gen = {$random} & ~32'b0; data = align(i, gen, size); reposit[i] = data; ahb_write(i, size, data); end for (i = start; i < (finish-size+1); i = i + size) begin data = reposit[i]; ahb_read(i, size, got); got = align(i, got, size); if (got !== data) begin $display("[%10d] %m A:%x D:%x, but %x expected", $time, i, got, data); error = error + 1; end end if (error == 0) $display("[%10d] %m OK: from %x to %x", $time, start, finish); end endtask //----------------------------------------------------------------------- // Burst transfer test //----------------------------------------------------------------------- task memory_test_burst; input [31:0] start; // start address input [31:0] finish; // end address input [7:0] leng; // burst length integer i; integer j; integer k; integer r; integer error; reg [31:0] data; reg [31:0] gen; reg [31:0] got; reg [31:0] reposit[0:1023]; integer seed; begin $display("%m: read-all-after-write-all burst test with %d-beat access", leng); error = 0; seed = 111; gen = $random(seed); k = 0; if (finish > (start+leng*4)) begin for (i = start; i < (finish-(leng*4)+1); i = i + leng*4) begin for (j = 0; j < leng; j = j + 1) begin data_burst[j] = $random; reposit[j+k*leng] = data_burst[j]; end @(posedge HCLK); ahb_write_burst(i, leng); k = k + 1; end gen = $random(seed); k = 0; for (i = start; i < (finish-(leng*4)+1); i = i + leng*4) begin @(posedge HCLK); ahb_read_burst(i, leng); for (j = 0; j < leng; j = j + 1) begin if (data_burst[j] != reposit[j+k*leng]) begin error = error+1; $display("%m A=%hh D=%hh, but %hh expected",i+j*leng, data_burst[j], reposit[j+k*leng]); end end k = k + 1; r = $random & 8'h0F; repeat(r) @(posedge HCLK); end if (error == 0) $display("%m %d-length burst read-after-write OK: from %hh to %hh",leng, start, finish); end else begin $display("%m %d-length burst read-after-write from %hh to %hh ???",leng, start, finish); end end endtask //----------------------------------------------------------------------- // As AMBA AHB bus uses non-justified data bus scheme, data should be // aligned according to the address. //----------------------------------------------------------------------- function [31:0] align; input [ 1:0] addr; input [31:0] data; input [ 2:0] size; // num of bytes begin `ifdef BIG_ENDIAN case (size) 1 : case (addr[1:0]) 0 : align = data & 32'hFF00_0000; 1 : align = data & 32'h00FF_0000; 2 : align = data & 32'h0000_FF00; 3 : align = data & 32'h0000_00FF; endcase 2 : case (addr[1]) 0 : align = data & 32'hFFFF_0000; 1 : align = data & 32'h0000_FFFF; endcase 4 : align = data&32'hFFFF_FFFF; default : $display($time,,"%m ERROR %d-byte not supported for size", size); endcase `else case (size) 1 : case (addr[1:0]) 0 : align = data & 32'h0000_00FF; 1 : align = data & 32'h0000_FF00; 2 : align = data & 32'h00FF_0000; 3 : align = data & 32'hFF00_0000; endcase 2 : case (addr[1]) 0 : align = data & 32'h0000_FFFF; 1 : align = data & 32'hFFFF_0000; endcase 4 : align = data&32'hFFFF_FFFF; default : $display($time,,"%m ERROR %d-byte not supported for size", size); endcase `endif end endfunction `include "ahb_transaction_tasks.v" endmodule这个模块主要是实现了两个testcase,一个是测试single传输，另一个测试burst传输。AHB读写传输任务被封装在ahb_transaction_tasks.v文件中： //------------------------------------------------------------------------------ // File : ahb_transaction_tasks.v // Editor : VSCode, Tab Size(4) // Description : AHB Transaction Tasks. // //------------------------------------------------------------------------------ `ifndef __AHB_TRANSACTION_TASKS_V__ `define __AHB_TRANSACTION_TASKS_V__ //----------------------------------------------------------------------- // AHB Read Task //----------------------------------------------------------------------- task ahb_read; input [31:0] address; input [2:0] size; output [31:0] data; begin @(posedge HCLK); HADDR <= #1 address; HTRANS <= #1 2'b10; // NONSEQ; HBURST <= #1 3'b000; // SINGLE; HWRITE <= #1 1'b0; // READ; case (size) 1 : HSIZE <= #1 3'b000; // BYTE; 2 : HSIZE <= #1 3'b001; // HWORD; 4 : HSIZE <= #1 3'b010; // WORD; default : $display($time,, "ERROR: unsupported transfer size: %d-byte", size); endcase @(posedge HCLK); while (HREADY !== 1'b1) @(posedge HCLK); HTRANS <= #1 2'b0; // IDLE @(posedge HCLK); while (HREADY === 0) @(posedge HCLK); data = HRDATA; // must be blocking if (HRESP != 2'b00) $display($time,, "ERROR: non OK response for read"); @(posedge HCLK); end endtask //----------------------------------------------------------------------- // AHB Write Task //----------------------------------------------------------------------- task ahb_write; input [31:0] address; input [2:0] size; input [31:0] data; begin @(posedge HCLK); HADDR <= #1 address; HTRANS <= #1 2'b10; // NONSEQ HBURST <= #1 3'b000; // SINGLE HWRITE <= #1 1'b1; // WRITE case (size) 1 : HSIZE <= #1 3'b000; // BYTE 2 : HSIZE <= #1 3'b001; // HWORD 4 : HSIZE <= #1 3'b010; // WORD default : $display($time,, "ERROR: unsupported transfer size: %d-byte", size); endcase @(posedge HCLK); while (HREADY !== 1) @(posedge HCLK); HWDATA <= #1 data; HTRANS <= #1 2'b0; // IDLE @(posedge HCLK); while (HREADY === 0) @(posedge HCLK); if (HRESP != 2'b00) $display($time,, "ERROR: non OK response write"); @(posedge HCLK); end endtask //----------------------------------------------------------------------- // AHB Read Burst Task //----------------------------------------------------------------------- task ahb_read_burst; input [31:0] addr; input [31:0] leng; integer i; integer ln; integer k; begin k = 0; @(posedge HCLK); HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b10; // NONSEQ if (leng >= 16) begin HBURST <= #1 3'b111; // INCR16 ln = 16; end else if (leng >= 8) begin HBURST <= #1 3'b101; // INCR8 ln = 8; end else if (leng >= 4) begin HBURST <= #1 3'b011; // INCR4 ln = 4; end else begin HBURST <= #1 3'b001; // INCR ln = leng; end HWRITE <= #1 1'b0; // READ HSIZE <= #1 3'b010; // WORD @(posedge HCLK); while (HREADY == 1'b0) @(posedge HCLK); while (leng > 0) begin for (i = 0; i < ln-1; i = i + 1) begin HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b11; // SEQ; @(posedge HCLK); while (HREADY == 1'b0) @(posedge HCLK); data_burst[k%1024] <= HRDATA; k = k + 1; end leng = leng - ln; if (leng == 0) begin HADDR <= #1 0; HTRANS <= #1 0; HBURST <= #1 0; HWRITE <= #1 0; HSIZE <= #1 0; end else begin HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b10; // NONSEQ if (leng >= 16) begin HBURST <= #1 3'b111; // INCR16 ln = 16; end else if (leng >= 8) begin HBURST <= #1 3'b101; // INCR8 ln = 8; end else if (leng >= 4) begin HBURST <= #1 3'b011; // INCR4 ln = 4; end else begin HBURST <= #1 3'b001; // INCR1 ln = leng; end @(posedge HCLK); while (HREADY == 0) @(posedge HCLK); data_burst[k%1024] = HRDATA; // must be blocking k = k + 1; end end @(posedge HCLK); while (HREADY == 0) @(posedge HCLK); data_burst[k%1024] = HRDATA; // must be blocking end endtask //----------------------------------------------------------------------- // AHB Write Burst Task // It takes suitable burst first and then incremental. //----------------------------------------------------------------------- task ahb_write_burst; input [31:0] addr; input [31:0] leng; integer i; integer j; integer ln; begin j = 0; ln = 0; @(posedge HCLK); while (leng > 0) begin HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b10; // NONSEQ if (leng >= 16) begin HBURST <= #1 3'b111; // INCR16 ln = 16; end else if (leng >= 8) begin HBURST <= #1 3'b101; // INCR8 ln = 8; end else if (leng >= 4) begin HBURST <= #1 3'b011; // INCR4 ln = 4; end else begin HBURST <= #1 3'b001; // INCR ln = leng; end HWRITE <= #1 1'b1; // WRITE HSIZE <= #1 3'b010; // WORD for (i = 0; i < ln-1; i = i + 1) begin @(posedge HCLK); while (HREADY == 1'b0) @(posedge HCLK); HWDATA <= #1 data_burst[(j+i)%1024]; HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b11; // SEQ; while (HREADY == 1'b0) @(posedge HCLK); end @(posedge HCLK); while (HREADY == 0) @(posedge HCLK); HWDATA <= #1 data_burst[(j+i)%1024]; if (ln == leng) begin HADDR <= #1 0; HTRANS <= #1 0; HBURST <= #1 0; HWRITE <= #1 0; HSIZE <= #1 0; end leng = leng - ln; j = j + ln; end @(posedge HCLK); while (HREADY == 0) @(posedge HCLK); if (HRESP != 2'b00) begin // OKAY $display($time,, "ERROR: non OK response write"); end `ifdef DEBUG $display($time,, "INFO: write(%x, %d, %x)", addr, size, data); `endif HWDATA <= #1 0; @(posedge HCLK); end endtask `endif使用VCS仿真，打印信息如下：图片图片整体仿真波形如下：图片不喜欢用DVE的话，也可以选择用Verdi查看波形，这种比较简单的调试，DVE也足够用了。下面贴一张突发传输的细节图：图片图片

IP&SOC设计 # SOC设计

刘航宇 3年前
0 657 1
2023-03-04
AMBA--AHB总线协议介绍（二） 1、突发提前终止在特定情况下，一个突发传输会被提前终止，此时，要求从机能根据突发信息采取正确的动作。从机能够通过监控HTRANS信号一个突发传输是否被提前终止。在突发传输开始后，从机每次传输都会监测HTRANS信号是否为SEQ或BUSY，当HTRANS信号上出现NONSEQ或者IDLE时，则表明前一次突发传输已经终止。当一个主机因为仲裁失败导致突发传输未能完成，则在该主机下一次获得总线所有权时，必须能够保证重建该突发完成剩余传输。例如，当主机只完成一个4拍突发传输的一拍，那么它必须使用一个未定长度的突发来完成剩下的三拍传输。下图表示了一个四拍的回环突发操作，从机在第一次传输插入了一个等待状态，该突发传输大小为4Byte,为4拍传输，所以地址将在16字节边界回环，因此传输到0x3C后，下一次的传输地址将返回到0x30：图片下图表示了一个4拍增量突发，在第一次传输时从机也插入了一个等待状态，地址是连续的，跨过了16字节地址地址边界：图片下图表示了一个8拍的回环突发传输，传输大小为4Byte，所以地址将在32字节边界回环，回环之后的地址为0x20：图片下图表示8拍增量突发，传输大小为2Byte，所以地址增量为2，同时传输会跨过16字节的地址边界：图片下图表示了未定义长度的突发传输，从图中可以看出，该图包含两个未定义长度的突发传输，第一个位起始地址为0x20，传输大小为2Byte；第二个突发起始地址为0x5C，传输大小为4Byte，地址增量为4：图片 2、控制信号和传输类型可突发类型信号一样，每次传输都会有一组控制信号来提供传输的附加信息。这些控制信号和地址总线具有相同的时序，和地址信号不同的是，这些控制信号在突发传输的过程中，必须保持不变。 2.1 传输方向 HWRITE为高时，表示写传输，并且主机需要数据广播到写数据总线（HWDATA）上；该信号为低时，表示读传输，从机必须产生数据到读数据总线（HRDATA）。 2.1 传输大小 HSIZE[2:0]表示传输大小，见下表：图片注：传输大小和传输类型一起被用于计算回环突发传输的地址边界。 2.3 保护控制 HPROT[3:0]为总线协议保护信号，用于定义存取的型态与特性，表示传输是否是：一次预取址或者数据访问；特权模式访问或者用户模式访问；对于带有存储器管理单元的主机来说这些信号也表示当前访问是带高速缓存（cache）的或是带缓冲（buffer）的； HPROT[3]高速缓存HPROT[2]带缓冲的HPROT[1]特权模式HPROT[0]数据/预取指描述---0预取指---1数据访问--0-用户模式访问--1-特权模式访问-0--无缓冲-1--带缓冲0---无高速缓存1---带高速缓存注意：并非所有的主机都能产生正确的保护控制信号，因此建议从机没有严格必要的情况下，不要使用HPROT信号。 3、地址译码 AHB总线中，会使用一个中央译码器来产生HSELx信号，用于选择从机，选择信号由地址高位信号组合译码产生。建议使用简单的译码方案来保证高速操作。从机只能在HREADY信号为高时，采样地址和控制信号以及HSELx,当HREADY信号为高时，表示传输完成。 AHB有几个特别的规定：（1）每个从机至少都有 1KB 的内存空间。（2）每个主机每次存取的空间不可超过 1KB。（3）如果在 NONSEQ 或 SEQ 型态下存取到不存在的地址时，会有一个预设的从机发出 ERROR 的响应信号。（4）如果在 IDLE 或 BUSY 型态下存取到不存在的地址时，会有 OKAY 的响应信号。（5）预设的从机是中央译码器的一部分。（6）根据系统设计，使用地址的高位来产生从机选择信号。（7）地址的低位送给从机以寻址其的内部存储器或缓存器图片 4、从机传输响应主机发起传输后，由从机决定传输如何进行。一旦传输发起，协议不允许主机取消传输。被访问的从机必须提供一个传输状态的响应。从机使用HREADY信号和HRESP[1:0]信号的组合，来提供传输状态。从机可以提供多种方式来完成传输：（1）立刻完成传输；（2）插入一个或多个等待状态以获得充分时间来完成传输；（3）发出一个错误应答表示传输失败；（4）延时传输的完成，允许主机和从机放弃总线，让其他主机先完成传输，再完成剩下的传输。 4.1 传输完成 HREADY信号用于扩展AHB传输中的数据相位，HREADY为低表示传输被扩展，为高表示传输完成。注意：每个从必须预先设定它放弃总线之前能插入的最大等待周期，用来计算访问总线的延时。推荐但不必须的是, 等待状态最多只可使用 16 个周期,已防止任何访问长时间占用总线。从机需要 HREADY 是双向信号(HREADY 做为总线上的信号，它是主机和从机的输入；同时每个从机自己的 HREADY 信号是输出。所以对于从机会有两个 HREADY 信号，一个来自总线的输入，一个自己给到多路器的输出。 4.2 传输响应 HRESP[1:0]的编码及传输响应信号如下表： HRESP[1:0]ReponseDescription00OKAY从机可以用HREADY (拉高)与OKAY 的信号响应，代表传送已成功完成。HREADY 被拉低，加上OKAY的信号可插入在任何的响应信号(ERROR、 RETRY 或SPLIT) 之间，也就是当从机在未能正确的选择ERROR、RETRY 或SPLIT时，可以插入HREADY (拉低)与OKAY信号，但是等待状态最多只可使用16个周期01ERROR此次数据传送发生错误，该信号必须维持两个时钟周期10RETRY传输未完成，主机应尝试再次发起传输，直到传输完毕，该信号必须维持两个时钟周期11SPLIT此信号必须维持两个周期，从机响应此信号表示此次的传送无法完成，要以分段传送方式来达成。等到从机可以完成时，会知会仲裁器，让重提数据传送要求的主机，完成传送4.3 双周期响应仅有OKAY响应可以在单周期给出，ERROR、RETRY、SPLIT响应至少需要两个周期。为了完成这些响应，从机会在倒数第二个周期驱动HRESP为ERROR或RETRY或SPLIT，同时拉低HREADY以获得一个额外的扩展周期。在最后一个周期，HREADY拉高，表示传输完成，同时保持HRESP。如果从机需要两个以上的周期来完成ERROR、RETRY、SPLIT响应，则从机可能在传输开始时，插入等待状态。在这段周期内，从机拉低HREADY，同时只能给出OKAY响应。需要双周期响应是AHB流水线传输的本质决定的，当从机发起ERROR、RETRY、SPLIT响应时，下一次传输的地址已经被广播到地址总线上了，双周期响应允许主机有足够的时间来取消该地址，并在下一次传输开始之前驱动HTRANS为IDLE。下图表示了一个RETRY应答，从图中可知，传输的起始地址为A，传输大小为4Byte，主机在获得响应之前，已经将地址设置为A+4，从机在地址A不能立即完成传输，因此给出RETRY响应，这个响应指示主机地址A的传输未完成，并且地址A+4的传输被IDLE传输类型取代。图片下图表示了传输中，从机需要一个周期（HRESP为OKAY）来决定给出何种响应的例子，之后从机给出双周期的ERROR响应结束了传输。图片 4.4 错误响应当主机收到一个 ERROR响应时，它可以选择结束当前的批量数据传送,也可以继续传送剩下的批量数据，但通常不这样做。在从机送出 ERROR的信号之前必须先送出OKEY + HREADY (LOW)的信号，而 ERROR 信号至少需要维持两个周期。如上图所示。（1）在第二个周期 S 送出 OKAY+ low HREADY 信号，使从机有充分的时间决定是否需要发出 ERROR 的信号；（2）主机收到ERROR应答后，立刻结束当前的数据传送；注意：从机必须维持ERROR至少两个周期 4.5 分块和重试分块和重试响应给从机提供了在无法立刻给传输提供数据时释放总线的机制。这两种响应都允许在总线上结束传输，因此允许更高优先级的主机获得总线访问权。 SPLIT和RETRY的不同之处在于仲裁器在发生SPLIT和RETRY后分配总线的方式：（1）对RETRY而言，仲裁器将继续使用常规优先级方案，因此只有拥有更高优先级的主机能获得总线访问权；（2）对SPLIT而言，仲裁器将调整优先级方案，以便其他任何主机申请总线即能获取总线，即使这个主机拥有更低的优先级。为了完成SPLIT传输，从机必须通知仲裁器数据何时可用，以便相应主机完成传输。 SPLIT传输机制增加了仲裁器和从机的复杂度，却拥有完全释放总线给其他主机使用的有点；RETRY相应就只允许更高优先级的主机使用总线。主机使用相同的方式处理SPLIT和RETRY相应。主机应继续请求总线，并尝试传输，知道传输完成或收到ERROR相应为止。 5、数据总线为了避免使用三态数据总线，AHB协议将数据总线分开为读数据总线和写数据总线。最小的数据位宽为32位，且位宽可增加。 5.1 写数据总线HWDATA[31:0] 1、写出数据由主机发出； 2、主机必须将数据总线上的数据维持住，直到从机完成数据的接收 (HREADY HIGH)； 3、所有传送所对应的地址都必须对齐，例如： 32 位的传送地址 Addr[1:0] = 00； 4、大端摆放法(big endian)或小端摆放法(little endian)都可使用 4.11小端摆放法(以 32 位为例) （1）低字节在 HWDATA.的低字节地址（2）Byte 0 (address offset = 0) 在 HWDATA[7:0] （3）Byte 1 (address offset = 1) 在 HWDATA[15:8] （4）Byte 2 (address offset = 2) 在 HWDATA[23:16] （5）Byte 3 (address offset = 3) 在 HWDATA[31:24] 4.12大端摆放法（1）低字节在 HWDATA.的高字节地址（2）Byte 0 (address offset = 0) 在 HWDATA[31:24] （3）Byte 1 (address offset = 1) 在 HWDATA[23:16] （4）Byte 2 (address offset = 2) 在 HWDATA[15:8] （5）Byte 3 (address offset = 3) 在 HWDATA[7:0] 5.2 读数据总线HRDATA[31:0] 读数据总线在读数据期间，由被选中的从机驱动，如果从机通过拉低HREADY信号来扩展传输，则从机只需在最后一个周期提供有效数据，由HREADY信号为高表示。端结构与写数据总线相同。从机只需要在OKAY响应周期提供有效数据，SPLIT、RETRY以及ERROR响应不需要提供有效的读数据。 6、总线仲裁机制仲裁机制确保了任何时刻只有一个主机可以访问总线。仲裁器的功能如下：（1）通过观察不同的总线请求信号，通过仲裁算法来决定哪个主机拥有最高优先级；（2）接收从机的完成分段传送的请求仲裁信号描述如下表所示： NameWidthDescriptionHBUSREQx1bit由主机到仲裁器，主机通过此信号对仲裁器提出使用总线的要求。主机可在任何时间要求仲裁器对于固定长度的传送，只要发起一次请求即可，仲裁器会依据HBURST[2:0]来判断传送的长度。对于未定的传送长度，主机必须持续提出请求，直到完成全部的传送为止。当所有主机都不需要使用总线时，必须在HTRANS.上送出IDLE信号，仲裁器就会将总线的使用权交给预设主机(default M)HLOCKx1bit此信号必须与HBUSREQx配合，表示一个不可分段的传送动作，HLOCKx必须再指定地址之前使能一个周期HGRANTx1bit由仲裁器输出到主机，仲裁器通知某个主机表示此主机得到总线的使用权.主机在HGRANT信号为高且HREADY信号也为高的那个HCLK上升沿处获得总线使用权 HMASTER4bit仲裁器以此信号表示当前是哪一个主机在使用总线，此信号也可用来控制地址多任务器HMASTERLOCK1bit仲裁器以此信号表示当前的总线是被锁住的，此信号与地址和控制信号具有相同的时序HSPLIT16bit一个可执行分段传送的从机以此信号让仲裁器知道要让哪一个主机完成其未完成的分段传送6.1 总线访问请求主机可以在任何周期内使用HBUSREQx信号来请求总线。仲裁器会在时钟上升沿根据内部的优先级仲裁算法决定接下来哪一个主机将获得总线访问权。通常仲裁器会在一个突发传输完成后才会授权另一个主机，但是如果需要的话，仲裁器也可以提前终止突发，将总线访问权授予更高优先级的主机。如果一个主机需要锁定总线，那么它必须声明HLOCKx信号，告知仲裁器其他主机不应该被授予总线。当主得到总线授权，并且正在执行一个定长的突发传输，它不需要继续总线请求即可完成这个 burst。仲裁器观察突发的进程，并使用 HBURST[2:0]来决定主机有多少个传送。如果主机希望在当前正在进行的突发之后继续 1 次传输，它应在当前突发期间重新声明请求信号。如果主机在突发传输过程中失去了总线访问权，那么它必须重新声明HBUSREQx信号以获得重新授权。对于未定长度的突发，主机需持续声明HBUSREQx，知道最后一个传输已经开始。因为在未定长度的突发中，仲裁器不知道何时可以改变总线授权。主机没有请求，也可能获得了总线控制权。这是因为当没有主机去请求总线时，总线会授权给一个默认的主机。所以当某个主机不需要总线访问，它需要把传送类型 HTRANS 设置为 IDLE，这点很重要。 6.2 授予总线访问仲裁器通过声明HGRANTx信号来表示当前拥有最高优先级的主机，HREADY信号为高时，主机将被授予总线，同时仲裁器改变HMASTER[3:0]来表示主机序号。下图表示一个零等待的总线授予访问：图片下图表示了有等待状态总线授予访问：图片数据总线的拥有权必须比地址总线的拥有权晚释放出去，这是因为数据周期发生在地址周期之后。（1）在 T5 正沿，从机送出 HREADY 信号，表示 M1成功传送最后一次传输的地址及控制信号（2）地址总线在 T5 正沿开始交换使用者，当 HGRANT_M2 AND HREADY = HIGH，表示地址总线交换成功（3）仲裁器必须知道 M1还有多少笔数据要传送，才可正确的发出 HGRANT_M2 信号（4）当仲裁器收到最后一个传输地址后，仲裁器就会改变 HGRANTx 信号（5）T5 刚开始时， M2 送出地址与控制信号（6）数据总线的交换只有在上一笔数据传送结束后才会开始（7）在 T7 正沿，开始数据总线的交换图片下图表示了仲裁器在一次突发结束后移交总线的例子：（1）仲裁器在倒数第二个地址被采样时（T5），改变HGRANTx信号；（2）新的HGRANTx信息将在最后一个地址被采样时（T7）同时被采样。图片下图表示了HGRANTx和HMASTER信号在系统中是如何被使用的： !注意：由于使用了中央地址译码器，每个主机可以立刻输出它想被执行的地址，而不用等到被授予总线。HGRANTx信号仅被主机用来决定它何时拥有总线，并考虑何时地址被选中的从机采样。HMASTER的延迟信号被用来控制写数据总线数据选择器。 6.3 锁定传输仲裁必须从观察每一个主机的 HLOCKx 信号，来决定什么时候主机希望执行一个锁定顺序传输。之后仲裁器负责确保没有其他主机被授权，直到这个锁定传输完成。在一个连续锁定传输之后，仲裁将总是还会保持当前的主机的授权来传一个附加的传送来保证锁定传输的序列的最后一个传送已经成功完成，并且没有收到 SPLIT or RETRY 的应答之一。所以推荐但并不是强制要求的做法是，主机在任何锁定传输后插入一个 IDLE 传输，在开始其它突传输之前，来提供一个仲裁切换的机会。仲裁器也负责声明HMASTERLOCK信号，该信号与地址和控制信号具有相同的时序。该信号指示从机当前传输时锁定的，因此必须在其他主机被授予总线之前处理完成。 6.4 默认总线主机每个系统都必须包含一个默认总线主机，当其他主机都不能使用总线时，该主机被授予总线。默认主机在获得授予总线时，只能执行IDLE传输。如果所有主机都还在等待 SPLIT传输的完成，也会将总线使用权交给默认主机。 7、分段传输从机可以用 SPLIT 来解决延迟太长的传输。仲裁器必须观察响应信号并且遮掉(mask)已被分段传送的主机，使其等候 HSPLIT 信号的通知后才授予其总线使用权。仲裁器必须在 HMASTER[3:0] 上产生一个标签表示哪一个主机正在执行数据传送。当从机要执行分段传输的动作时，这个从机必须存下主机序号。当从机可以完成被分段的传输时会在 HSPLITx[15:0]信号上，送出要完成传送的主机序号。仲裁器以 HSPLITx[15:0] 来决定哪一个主机可以重新获得 bus 的使用权。仲裁器会在每个周期去观察 HSPLITx 信号。当有多个 HSPLITx 信号时，会被逻辑或在一起传送给仲裁器。 7.1 分段传输顺序 1、主机送出地址与控制信号，开始传送。 2、被寻址到的从机立即提供数据，或者送出SPLIT应答信号(如果需要等些周期来获得数据)。在每次的传输，仲裁器会广播出当前是哪一个主机在使用总线。从机需要记录主机序列号，以便后面重传使用。 3、有 SPLIT 信号响应时，仲裁器会将总线使用权交给别的主机使用，如果所有其它主机都收到SPLIT 信号，则移交给默认主机。 4、当从机要完成分段传送时，从机会在 HSPLITx 上设定对应的主机 ID，来指示哪个主机可以被允许再次访问总线。 5、仲裁器会在每个周期观察 HSPLITx 信号，如果有变化，就更改正确的主机的优先权。 6、仲裁器将会允许重新要求使用权的主机，但如果有更高优先级的主机在用总线，可能会延迟。 7、从机会响应 OKAY 信号表示传送完成。 7.2 多重分段传输只要一个主机有额外的 HBUSREQ 与 HGRANT 线，即可发出超过一个以上的传送要求。仲裁器将一组信号 (REQ and GNT) 视为一个主机。可分段传输的从机可被设计去处理额外的传送要求而不需纪录额外的地址与控制信号，但要记录主机序号。从机可利用 HSPLITx 来表示当前正在处理的是哪一个主机要完成分段传输。仲裁器可重新仲裁这些主机的请求，高优先权的主机可被重新给予使用权。 7.3 预防死锁 Deadlock可能发生在很多不同的主机对同一个发出 SPLIT 和 RETRY 的从机身上，而该从机又无法处理那么多 SPLIT and RETRY 时，便会发生 deadlock。 Deadlock 可以透过限制分段传送的数目(最多 16 个)来避免。从机并不会记录下每个要求的地址与控制讯息，如果要作 SPLIT 的话，只会记录下当前传送对象的 ID 讯息。当 S 可完成分段传送时，才会锁定要求的地址与控制讯息。从机会依序地让仲裁器知道从机要服务哪些要求。从机可以任何顺序处理要求的服务。重传：当从机无法在很短的时间内完成传送的动作时，它可以要求主机重传。从机一次只可对一个主机发出 RETRY 信号，确定所服务的主机是同一个时， RETRY 的动作才能完成。如果 RETRY 是不同主机时可以采取下列措施：（1）给一个 error 回应（2）通知仲裁器（3）产生中断（4）重置系统 7.4 分块传输的总线移交当主机收到 SPLIT 或 RETRY 响应信号时，必须先进入 IDLE 状态并且重新请求总线使用权，一个新的主机会在 IDLE 周期结束前由仲裁器决定出来。主机在收到 SPLIT 或 RETRY 信号后须立刻进入 IDLE 状态。（1）在 T2 与 T3，从机会传两个周期的 SPILT 信号。（2）该主机在 T3 正沿时发现有 SPLIT 响应信号，于是进入 IDLE 状态。（3）仲裁器在 T3 正沿时，决定下一个总线的使用者。（4）在 T4，新的主机送出地址与控制信号图片

IP&SOC设计 # SOC设计

刘航宇 3年前
0 790 1
AMBA--AHB总线协议介绍（一） 1、AHB总线概述 AHB：Advanced High-performance Bus,即高级高性能总线。AHB总线是SOC芯片中应用最为广泛的片上总线。下图是一个典型的基于AMBA AHB总线的微控制器系统：图片 SOC架构图片基于AMBA AHB的设计中可以包含一个或多个总线主机，通常一个系统里至少包含一个处理器和一个测试接口；DMA和DSP作为总线主机同样是比较常见的。典型的AHB总线设计包括一下几个部分：（1）AHB主机：主机可以通过提供地址和控制信息发起读写操作；同一时刻总线上只允许一个主机占用总线。（2）AHB从机：从机需在给定的地址空间范围内响应总线上的读或写操作；从机通过信号将成功、失败、等待数据传输等信息返回至有效的主机。（3）AHB仲裁器：总线仲裁器确保同一时刻只有一个主机被允许发起传输。所有的AHB总线都必须包含一个仲裁器，即使是在单主机总线系统中。（4）AHB译码器：译码器的作用是对传输中的地址信号进行译码，并提供给从机一个选择信号。所有的AHB总线中都必须包含一个中央译码器。 2、总线互联 AMBA AHB总线协议被设计为一个使用中央多路选择器的互联方案，如下表：图片基于这种方案，所有的主机在需要发起传输时，都可以驱动地址和控制信号，由仲裁器决定哪一个主机的地址和控制信号（写传输时包含写数据信号）连通到总线上的所有从机。同时总线需要一个中央译码器，用于控制读数据和应答信号的多路数据选择器，该多路数据选择器用于选择传输中涉及的从机的相关信号。 3、AHB信号 AHB信号以字母H作为前缀，如下表所示 NameWidthSourceDescriptionHCLK1bit时钟源总线所有传输都基于此时钟，所有信号的时序都与时钟上升沿有关HRESETn1bit复位控制器总线复位信号，总线上唯一低电平有效的信号HADDR32bit主机32位地址总线HTRANS2bit主机表明当前传输的类型HSIZE2bit主机表明传输的大小，典型的是字节(8-bit)、半字(16-bit)、字(32-bit)，协议允许最大传输大小是1024 bitHWRITE1bit主机传输写信号，高电平表示写传输，低电平表示读传输HBURST3bit主机有自己的HBURST信号有自己的HBURST信号HPROT4bit主机保护控制信号。主要应用于期望实现某些程度的保护级别的模块中HWDATA32bit主机写传输数据。要求最低位宽位32位HSELx1bit译码器从机选择信号，每个AHB从机都有自己的HSEL信号，该信号有效时，表明选中相应从机HRDATA32bit从机读数据总线，用于读操作期间从机向主机传输数据HREADY1bit从机该信号为高时，表明总线传输完成。也可以拉低该信号用以扩展传输HRESP2bit从机传输响应信号。提供四种响应OKAY、ERROR、RETRY、SPLITAMBA AHB也需要一些信号用于支持多主机总线操作，其中一些仲裁信号需要点对点连接： NameWidthSourceDescriptionHBUSREQx1bit主机主机x发送至仲裁器的总线请求信号，总线系统中最多有16个主机，每个主机都有一个HBUSREQ信号HLOCKx1bit主机该信号为高时，表示主机x发起锁定传输HGRANTx1bit仲裁器表明主机x在当前总线上拥有最高的优先级，当HREADY信号为高时，地址/控制信号的所有权将发生变化，故主机x需在HREADY与HGRANTx信号同时为高时，获得总线控制权HMASTER4bit仲裁器表明哪一个主机当前拥有地址/控制信号的所有权HMASTLOCK1bit仲裁器表明当前传输为锁定顺序传输，此信号与HMASTER具有相同时序HSPLITx16bit从机用于指示仲裁器，哪一个主机可以继续完成分块传输4、AMBA AHB操作概述在一次AHB传输开始之前，主机必须被授予总线访问权。这个过程起始于主机向仲裁器发出一个总线请求，由仲裁器决定该主机何时被授予总线使用权。被授权的主机通过驱动地址和控制信号来发起一次AHB传输，这些信号提供了地址、传输方向、传输宽度等信息，以及会表明当前传输是否为突发传输的一部分。AHB支持两种形式的突发传输：（1）增量突发，在地址边界不进行回环；（2）回环突发，在特定地址边界回环写数据总线用于将数据从主机发送到从机，读数据总线用于将数据从从机传输到主机。每次数据传输包含：（1）一个地址和控制周期；（2）一个或多个数据周期由于地址不支持扩展，所以所有的从机必须在地址周期内采样地址，而数据可以通过HREADY信号进行扩展延长，当HREADY信号为低，总线将插入等待状态，以此提供从机额外的采样数据或者提供数据的时间。在传输中，从机使用应答信号HRESP[1:0]来表示传输状态：（1）OKAY：OKAY响应表示传输正常，且当HREADY信号为高时，表示传输成功；（2）ERROR：ERROR响应表示发生了传输错误，并且传输失败；（3）RETRY and SPLIT：RETRY和SPLIT都表示当前传输未能即刻完成，但是主机应继续尝试传输一般而言，仲裁器授权另一个主机前，允许当前被授权主机完成突发传输。然而，为了避免过多的仲裁延迟（当前主机占用过多总线周期），总线可以打断一个突发传输，在这种情况下，主机必须重新申请总线，以完成后续的突发传输。 5、基本传输一个AHB传输包含两个部分：（1）地址相位，仅包含一个时钟周期；（2）数据相位，可以使用HREADY信号，维持多个时钟周期下图表示了一个无等待状态的简单传输：图片在无等待的简单传输中，主机在HCLK的上升沿驱动地址和控制信号到总线上，在下一个时钟上升沿时，从机对地址和控制信号进行采样，从机采样得到地址和控制信息后，可以驱动应答信号给与主机适当的响应，主机在第三个时钟的上升沿对应答信号进行采样。这个简单的例子演示了在不同的时钟周期地址和数据相位是怎样产生的。实际上，当前传输的地址相位都对应于前一次传输的数据相位，这种地址和数据交叠现象，是总线能够进行流水线传输的基础，这样不仅能够获得更高的传输性能，也能为从机进行响应提供充足的时间。从机可以在数据相位中，插入等待状态，以此获得更多得时间来完成传输：图片注意：（1）在写传输中，主机需要在整个扩展周期内保持写数据信号稳定（2）在读传输中，从机没必要提供有效数据，知道传输结束时当传输以这种方式做扩展时，将对下一个传输的地址相位产生一个扩展的副作用，如下图所示：图片该图表示了三个不相关的地址A、B、C上的传输，图中地址A和C的传输都没有等待状态，地址B的传输通过HREADY信号的拉低插入了一个等待的数据相位，这样导致了地址C传输的地址相位进行了扩展。 6、传输类型 AHB传输类型可以分为四种，通过HTRANS[1:0]的取值来划分： HTRANSTypeDescription00IDLE表明没有数据传输的要求。IDLE 用于主机被授予总线，但不希望进行数据传输的情况。对于IDLE传输，从机必须提供一个零等待的OKAY应答，并且忽略该传输01BUSYBUSY传输类型允许主机在突发传输中插入空闲周期。表明主机正在进行突发传输，但下次传输不能立即有效。当主机使用BUSY传输类型时，地址和控制信号必须对应突发中的下一次传输。从机必须提供一个零等待的OKAY应答，并且忽略该传输。10NONSEQ表示突发传输中的第一次传输或者非突发的单次传输，地址和控制信号与前次传输无关.11SEQ突发传输中剩余的传输时连续的，地址和前一次传输是相关的,当前地址值等于前一次传输的地址值加上传输大小(字节)，控制信息和前一次传输相同。在回环的突发传输中，传输的地址在地址边界处回环，回环值的大小等于传输大小(字节) 乘以传输次数(4、8或16) )下图是一个不同传输类型的例子：图片从图中可以看出：第一个传输为以此突发传输的开始（T1），所以其传输类型为NONSEQ；主机不能立刻执行突发传输中的第二次传输，所以使用了BUSY的传输类型(T2)来延迟下一次传输的开始，注意此时地址已经时下次传输的地址，控制信号和下次传输保持一致，主机只插入了一个BUSY，所以T3执行第二次传输；主机执行第三次传输（T4），由于从机将HREADY信号拉低，插入了一个等待周期，引起地址相位的扩展； T6周期完成第三次传输，T7周期完成第四次传输（图中T8边沿）。 7、突发操作 AMBA AHB协议定义了4、8和16拍的突发，未定义长度的突发传输以及单次传输；协议支持增量和回环的突发方式。增量突发方式访问连续地址空间，每次传输的地址是前一次传输地址增加一个增量偏移；回环突发中，如果传输的其实地址并未和突发中的字节总数对齐，则突发传输地址将在达到边界处回环。例如：一个4拍回环突发的字（4字节）访问将在16字节的边界处回环，如果传输的起始地址为0x34，那么突发中将包含4个地址：0x34,0x38,0x3C,0x30。 AMBA AHB 有8种突发操作，使用信号HBRUST[2:0]表示： HTRANSTypeDescription000SINGLE单一传输001INCR未指定长度的增量突发010WRAP44拍回环突发011INCR44拍增量突发100WRAP88拍回环突发101INCR88拍增量突发110WRAP1616拍回环突发111INCR1616拍增量突发突发不能超过1K的地址边界，所以主机尽量不要发起将要跨过地址边界的定长的增量突发。一次突发传输的数据总量，等于节拍数乘以每拍包含的字节数。所以突发传输必须将地址边界和数据大小对齐，例如，字传输必须对齐到字地址边界，即A[1:0]=00；半字传输必须对齐到半字地址边界，即A[0]=0。

IP&SOC设计 # SOC设计

刘航宇 3年前
0 1,876 2
AMBA--APB总线协议及Verilog实现与仿真 1、APB总线简介 APB:Advanced Peripheral Bus,高级外设总线，具备以下特性：（1）低功耗；（2）接口协议简单；（3）总线传输使用时钟上升沿进行，便于时序分析；（4）应用广泛，支持多种外设。所有的APB模块均是APB从机。 2、APB信号列表所有的APB总线信号都以字母P作为前缀，下表列出了APB信号的名称以及对信号的描述： NameWidthI/ODescriptionPCLK1bitInAPB总线时钟，所有传输只能发生在PCLK的上升沿PRESETn1bitInAPB总线复位信号，低电平有效PADDR32bitInAPB地址总线PSEL1bitInAPB从机片选信号PENABLE1bitInAPB选通信号，高电平表示APB传输的第二个周期PWRITE1bitInAPB读写控制信号，高表示写，低表示读PRDATA32bitOutAPB读数据信号，最高为32位PWDATA32bitInAPB写数据信号，最高为32位3、APB总线时序（1）写时序图片写传输开始于T2时刻，在改时钟上升沿时刻，地址、写信号、PSEL、写数据信号同时发生变化，T2时钟，即传输的第一个时钟被称为SETUP周期。在下个时钟上升沿T3,PENABLE信号拉高，表示ENABLE周期，在该周期内，数据、地址以及控制信号都必须保持有效。整个写传输在这个周期结束时完成。（2）读时序图片读传输开始于T2时刻，在改时钟上升沿时刻，地址、写信号、PSEL信号同时发生变化，在下个时钟上升沿T3,PENABLE信号拉高，从机必须在ENABLE周期内提供读数据，读数据信号将在T4上升沿时刻被采样。经历2个cycle就读数据，不需要握手 4、Verilog实现下面编写一个简单的基于APB接口的memory读写控制程序供读数据，读数据信号将在T4上升沿时刻被采样。 `timescale 1ns / 1ps module apb_sram #( parameter SIZE_IN_BYTES = 1024 ) ( //---------------------------------- // IO Declarations //---------------------------------- input PRESETn, input PCLK, input PSEL, input [31:0] PADDR, input PENABLE, input PWRITE, input [31:0] PWDATA, output reg [31:0] PRDATA ); //---------------------------------- // Local Parameter Declarations //---------------------------------- localparam A_WIDTH = clogb2(SIZE_IN_BYTES); //---------------------------------- // Variable Declarations //---------------------------------- reg [31:0] mem[0:SIZE_IN_BYTES/4-1]; wire wren; wire rden; wire [A_WIDTH-1:2] addr; //---------------------------------- // Function Declarations //---------------------------------- function integer clogb2; input [31:0] value; reg [31:0] tmp; reg [31:0] rt; begin tmp = value - 1; for (rt = 0; tmp > 0; rt = rt + 1) tmp = tmp >> 1; clogb2 = rt; end endfunction //---------------------------------- // Start of Main Code //---------------------------------- // Create read and write enable signals using APB control signals assign wren = PWRITE && PENABLE && PSEL; // Enable Period assign rden = ~PWRITE && ~PENABLE && PSEL; // Setup Period assign addr = PADDR[A_WIDTH-1:2]; // Write mem always @(posedge PCLK) begin if (wren) mem[addr] <= PWDATA; end // Read mem always @(posedge PCLK) begin if (rden) PRDATA <= mem[addr]; else PRDATA <= 'h0; end endmodule测试代码： `timescale 1ns / 1ps `ifndef CLK_FREQ `define CLK_FREQ 50000000 `endif module top_tb(); //---------------------------------- // Local Parameter Declarations //---------------------------------- parameter SIZE_IN_BYTES = 1024; localparam CLK_FREQ = `CLK_FREQ; localparam CLK_PERIOD_HALF = 1000000000/(CLK_FREQ*2); //---------------------------------- // Variable Declarations //---------------------------------- reg PRESETn = 1'b0; reg PCLK = 1'b0; reg PSEL; reg [31:0] PADDR; reg PENABLE; reg PWRITE; reg [31:0] PWDATA; wire [31:0] PRDATA; reg [31:0] reposit[0:1023]; //---------------------------------- // Start of Main Code //---------------------------------- apb_sram #( .SIZE_IN_BYTES (SIZE_IN_BYTES) ) u_apb_sram ( .PRESETn (PRESETn), .PCLK (PCLK), .PSEL (PSEL), .PADDR (PADDR), .PENABLE (PENABLE), .PWRITE (PWRITE), .PWDATA (PWDATA), .PRDATA (PRDATA) ); // generate PCLK always #CLK_PERIOD_HALF begin PCLK <= ~PCLK; end // generate PRESETn initial begin PRESETn <= 1'b0; repeat(5) @(posedge PCLK); PRESETn <= 1'b1; end // test memory initial begin PSEL = 1'b0; PADDR = ~32'h0; PENABLE = 1'b0; PWRITE = 1'b0; PWDATA = 32'hffff_ffff; wait(PRESETn == 1'b0); wait(PRESETn == 1'b1); repeat(3) @(posedge PCLK); memory_test(0, SIZE_IN_BYTES/4-1); repeat(5) @(posedge PCLK); $finish(2); end // memory test task task memory_test; // starting address input [31:0] start; // ending address, inclusive input [31:0] finish; reg [31:0] dataW; reg [31:0] dataR; integer a; integer b; integer err; begin err = 0; // read-after-write test for (a = start; a <= finish; a = a + 1) begin dataW = $random; apb_write(4*a, dataW); apb_read (4*a, dataR); if (dataR !== dataW) begin err = err + 1; $display($time,,"%m Read after Write error at A:0x%08x D:0x%x, but 0x%x expected", a, dataR, dataW); end end if (err == 0) $display($time,,"%m Read after Write 0x%x-%x test OK", start, finish); err = 0; // read_all-after-write_all test for (a = start; a <= finish; a = a + 1) begin b = a - start; reposit[b] = $random; apb_write(4*a, reposit[b]); end for (a = start; a <= finish; a = a + 1) begin b = a - start; apb_read(4*a, dataR); if (dataR !== reposit[b]) begin err = err + 1; $display($time,,"%m Read all after Write all error at A:0x%08x D:0x%x, but 0x%x expected", a, dataR, reposit[b]); end end if (err == 0) $display($time,,"%m Read all after Write all 0x%x-%x test OK", start, finish); end endtask // APB write task task apb_write; input [31:0] addr; input [31:0] data; begin @(posedge PCLK); PADDR <= #1 addr; PWRITE <= #1 1'b1; PSEL <= #1 1'b1; PWDATA <= #1 data; @(posedge PCLK); PENABLE <= #1 1'b1; @(posedge PCLK); PSEL <= #1 1'b0; PENABLE <= #1 1'b0; end endtask // APB read task task apb_read; input [31:0] addr; output [31:0] data; begin @(posedge PCLK); PADDR <= #1 addr; PWRITE <= #1 1'b0; PSEL <= #1 1'b1; @(posedge PCLK); PENABLE <= #1 1'b1; @(posedge PCLK); PSEL <= #1 1'b0; PENABLE <= #1 1'b0; data = PRDATA; // it should be blocking end endtask `ifdef VCS initial begin $fsdbDumpfile("top_tb.fsdb"); $fsdbDumpvars; end initial begin `ifdef DUMP_VPD $vcdpluson(); `endif end `endif endmodule该测试用例，主要实现了APB读和写的task，用于产生APB读写时序，对memory的测试分成连个部分，一个是每进行一次写传输后，紧接着进行同地址的读传输，让后对比读写结果一致性；另一个测试是在连续写一段地址后，再全部读出改地址段的数据，完成读操作后进行数据比对。下面是仿真打印信息图片 APB写传输时序的仿真波形如下：图片 APB写传输时序的仿真波形如下：图片

IP&SOC设计 # SOC设计

刘航宇 3年前
0 2,872 2
Verilog RTL级低功耗设计-门控时钟及时钟树在ASIC/FGPA设计中，我们外界控制所设计的模块时候需要实现告诉他，我要给你输入信号了,你的工作了，反之你不用工作，这个就是门控时钟，就是使能信号EN，一般来说我们用EN控制CLK的产生。芯片功耗组成中，有高达40%甚至更多是由时钟树消耗掉的。这个结果的原因也很直观，因为这些时钟树在系统中具有最高的切换频率，而且有很多时钟buffer，而且为了最小化时钟延时，它们通常具有很高的驱动强度。此外，即使输入和输出保持不变，接收时钟的触发器也会消耗一定的功耗。而且这些功耗主要是动态功耗。那么减少时钟网络的功耗消耗，最直接的办法就是如果不需要时钟的时候，就把时钟关掉。这种方法就是大家熟悉的门控时钟：clock gating。(大家电路图中看到的CG cell就是门控时钟了) 目录 1门控时钟的结构1.1与门门控 1.2 锁存门控 1.3 寄存门控 1.4 门控时钟结构选择 2 RTL中的门控时钟附加：门控时钟的时钟树设计 3 RTL 门控时钟编码风格后记 1门控时钟的结构 1.1与门门控如果让我们设计一个门控时钟的电路，我们会怎么设计呢？最直接的方法，不需要时钟的时候关掉时钟，这就是与操作，我们只需要把enable和CLK进行“与”操作不就行了么，电路图如下：图片这种直接将控制EN信号和时钟CLK进行与操作完成门控的方式，可以完成EN为0时，时钟被关掉。但是同时带来另外一个很大的问题：毛刺图片如上图所示，EN是不受控制的，随时可能跳变，这样纯组合输出GCLK就完全可能会有毛刺产生。时钟信号上产生毛刺是很危险的。实际中，这种直接与门的方式基本不会被采样。所以我们需要改进电路，为了使门控时钟不产生毛刺，我们必须对EN信号进行处理，使其在CLK的高低电平期间保持不变，或者说EN的变化就是以CLK为基准的。 1 很自然的我们会想到触发器，只要把EN用CLK寄存一下，那么输出就是以CLK为基准的； 2 其实还有一种办法是锁存器，把EN用锁存器锁存的输出，也是以CLK为基准的。 1.2 锁存门控我们先看一下第二种电路，增加锁存器的电路如下：图片对应的时序如下：图片可以看到，只有在CLK为高的时候，GCLK才可能会输出高，这样就能消除EN带来的毛刺。这是因为D锁存器是电平触发，在clk=1时，数据通过D锁存器流到了Q；在Clk=0时，Q保持原来的值不变。虽然达到了我们消除毛刺的目的，但是这个电路还有两个缺点： 1如果在电路中，锁存器与与门相隔很远，到达锁存器的时钟与到达与门的时钟有较大的延迟差别，则仍会出现毛刺。 2 如果在电路中，时钟使能信号距离锁存器很近，可能会不满足锁存器的建立时间，会造成锁存器输出出现亚稳态。如下图分析所示：图片上述的右上图中，B点的时钟比A时钟迟到，并且Skew > delay，这种情况下，产生了毛刺。为了消除毛刺，要控制Clock Skew，使它满足Skew ENsetup 一 (D->Q)，这种情况下，也产生了毛刺。为了消除毛刺，要控制Clock Skew，使它满足|Skew|< ENsetup一(D->Q)。 1.3 寄存门控如1.1中提到的，我们还有另外的解决办法，就是用寄存器来寄存EN信号再与上CLK得到GCLK，电路图如下所示：图片时序如下所示：图片由于DFF输出会delay一个周期，所以除非CLKB上升沿提前CLKA很多，快半个周期，才会出现毛刺，而这种情况一般很难发生。但是，这种情况CLKB比CLKA迟到，是不会出现毛刺的。当然，如果第一个D触发器不能满足setup时间，还是有可能产生亚稳态。 1.4 门控时钟结构选择那么到底采用哪一种门控时钟的结构呢？是锁存结构还是寄存结构呢？通过分析，我们大概会选择寄存器结构的门控时钟，这种结构比锁存器结构的问题要少，只需要满足寄存器的建立时间就不会出现问题。那么实际中是这样么？答案恰恰相反，SOC芯片设计中使用最多的却是锁存结构的门控时钟。原因是:在实际的SOC芯片中，要使用大量的门控时钟单元。所以通常会把门控时钟做出一个标准单元，有工艺厂商提供。那么锁存器结构中线延时带来的问题就不存在了，因为是做成一个单元，线延时是可控和不变的。而且也可以通过挑选锁存器和增加延时，总是能满足锁存器的建立时间，这样通过工艺厂预先把门控时钟做出标准单元，这些问题都解决了。那么用寄存器结构也可以达到这种效果，为什么不用寄存器结构呢？那是因为面积！一个DFF是由两个D锁存器组成的，采样D锁存器组成门控时钟单元，可以节省一个锁存器的面积。当大量的门控时钟插入到SOC芯片中时，这个节省的面积就相当可观了。所以，我们在工艺库中看到的标准门控时钟单元就是锁存结构了：图片当然，这里说的是SOC芯片中使用的标准库单元。如果是FPGA或者用RTL实现，个人认为还是用寄存器门控加上setup约束来实现比较稳妥。门控时钟代码 always@(CLK or CLK_EN) if(!CLK) CLK_TEMP<=CLK_EN assign GCLK=CLK&CLK_TEMP2 RTL中的门控时钟通常情况下，时钟树由大量的缓冲器和反相器组成，时钟信号为设计中翻转率最高的信号，时钟树的功耗可能高达整个设计功耗40%。加入门控时钟电路后，由于减少了时钟树的翻转，节省了翻转功耗。同时，由于减少了寄存器时钟引脚的翻转行为，寄存器的内部功耗也减少了。采用门控时钟，可以非常有效地降低设计的功耗，一般情况下能够节省20%~60%的功耗。那么RTL中怎么才能实现门控时钟呢？答案是不用实现。现在的综合工具比如DC会自动插入门控时钟。如下图所示：图片这里有两点需要注意：插入门控时钟单元后，上面电路中的MUX就不需要了，如果数据D是多bit的（一般都是如此），插入CG后的面积可能反而会减少；如果D是单bit信号，节省的功耗就比较少，但是如果D是一个32bit的信号，那么插入CG后节省的功耗就比较多了。这里的决定因素就是D的位宽了，如果D的位宽很小，那么可能插入的CG面积比原来的MUX大很多，而且节省的功耗又很少，这样得不偿失。只有D位宽超过了一定的bit数后，插入CG的收益就比较大。那么这个临界值是多少呢？不同的工艺可能不一样，但是DC给的默认值是3. 也就是说，如果D的位宽超过了3bit，那么DC就会默认插入CG，这样综合考虑就会有收益。我们可以通过DC命令： set_clock_gating_style -minimum_bitwidth 4 来控制芯片中，对不同位宽的寄存器是否自动插入CG。一般情况都不会去修改它。附加：门控时钟的时钟树设计在时钟树的设计中，门控时钟单元应尽量摆放在时钟源附近，即防止在门控时钟单元的前面摆放大量的时钟缓冲器(Buffer)。这样，在利用门控时钟电路停时钟时不仅能将该模块中的时钟停掉，也能将时钟树上的时钟缓冲器停止反转,有效地控制了时钟树上的功耗。如图11-24所示，在布局时将门控时钟电路的部件摆放在一起，并摆放在时钟源GCLK附近，停掉时钟后，整个时钟树_上的缓冲器(CTS)和时钟树驱动的模块都停止了翻转。通常的SoC设计中，门控时钟单元会被做成一个硬核或标准单元。图片 3 RTL 门控时钟编码风格组合逻辑中，为避免生成锁存器，好的代码风格是if语句都加上else，case语句都加上default。时序逻辑中，为了让综合工具能够自动生成门控时钟，好的代码风格则是“若无必要，尽量不加else和default”——以减小数据翻转机会。虽然现在综合工具可以自动插入门控时钟，但是如果编码风格不好，也不能达到自动插入CG的目的。比较下面两种RTL写法：图片左边的RTL代码能够成功的综合成自动插入CG的电路；右边的RTL不能综合成插入CG的电路；右边电路在d_valid为低时，d_out也会一直变化，其实没有真正的数据有效的指示信号，所以综合不出来插入CG的电路。需要注意的是，有的前端设计人员，为了仿真的时候看的比较清楚，很容易会写成右边的代码，这样不仅不能在综合的时候自动插入CG来减少功耗；而且增加了d_out的翻转率，进一步增加了功耗。在不用的时候把数据设成0并不能减少功耗，保持数据不变化才能减少toggle，降低功耗！所以我们在RTL编写的时候一定要注意。作为前端设计者，了解这些知识就足够了，如果想深入了解综合的控制，可以去了解 set_clock_gating_style 这个核心控制命令后记门控时钟是低功耗技术的一种常规方法，应用已经很成熟了，所以很多人会忽视它的存在和注意事项，也不了解它的具体时序。本文从SOC前端设计的角度详细解释了各种门控时钟的结构和RTL编码需要注意的事项，希望能对设计人员有所帮助。

FPGA&ASIC IP&SOC设计 # ASIC/FPGA # SOC优化技术

刘航宇 3年前
0 2,560 3

315 文章数

561 评论量

人生倒计时

最新回复

aijun
2026-08-14

那些 AI 爬虫爬得服务器资源飚的高高的。
小帅
2026-08-13

文章不错
学习
2026-08-13

很好的资料