来自：http://www.eefocus.com/antaur/blog/17-08/423773_0818c.html
0.引言
构建SoC系统，毕竟是需要实现PS和PL间的数据交互，而像上一讲那样PL主机与PL从机之间通过AXI4-Lite总线进行交互有点杀鸡用牛刀了。
如果PS与PL端进行数据交互，可以直接设计PL端为从机，PS端向PL端的reg写入数据即可，但是对于图像处理等大数据量的数据交互来说，PL端的BRAM毕竟容量有限，很难用BRAM作为两者间的数据缓存器。对于这样的应用来说，利用DDR3作为PS端与PL端之间交互的数据缓存器是最合适不过的。（当然，对于大数据量的数据交互，利用AXI4-Lite总线模式效率太低，最佳选择是AXI4-Stream，这是后话，后面在进行研究。）
学习笔记3已经实现了PS端对DDR3的读写操作，本节研究如何再实现PL端对DDR3的读写操作，当然了在真正的工程系统中，还需要设计良好的读写同步，防止竞争冲突，这就属于系统设计层面的了，我再这里暂时忽略不考虑。
本节暂时不涉及PS端对DDR3的操作，而仅仅研究PL端如何对DDR3进行读写操作。
1.工程规划
再ZedBoard板子的硬件设计方案中，DDR芯片的管脚是绑定到Zynq的DDR接口上的。
而Zynq系统的这个DDR总线接口有是链接在其内部“Memory Interfaces”中的“DDR2/3,LPDDR2 Controller”可配置硬核上的。
因此，要想PL访问板上的DDR3存储器，必须借道Zynq中的“Memory Interfaces----DDR2/3,LPDDR2 Controller”（后文简称“DDR3 Controller”）。根据之前的经验，在Zynq系统中，ARM Core（CPU）能够访问硬核“DDR3 Controller”，根据经验可以确定“DDR3 Controller”一定是一个从设备，而PL要想访问“DDR3 Controller”的话，PL一定要是一个主设备，由PL发起读写操作。
“DDR3 Controller”是封装在Zynq子系统中的，因此，PL必须连接Zynq的从机接口。从上图可以看出，Zynq有两个从机接口，分别是“32b GP AXI Slave Ports”和“High Performance AXI 32b/64b Slave Ports”根据名称可以看出，一个是高性能的，另一个应该是普通的。之前Zynq作为主机连接AXI4-Lite从设备时，走的是“32b GP AXI Master Ports”，可以辅助证明，对于本节应用，走的接口应该是“32b GP AXI Slave Ports”。
交互数据将会经过Zynq子系统的内部总线（用空再考证一下是什么名称）控制器“Central Interconnect”转发给Memory Interfaces。具体数据交互路径如下图所示：
根据上述分析，SoC系统集成方案框图如下：
根据之前的经验，利用向导生成的PL端AXI4-Lite Master IP 用户用例再txn负脉冲触发下，主机模块的逻辑是连续4次（次数默认为4，可通过修改参数C_M00_AXI_TRANSACTIONS_NUM的数值改变次数）向递增的地址区间写入4组测试数据，测试数据每次加1。然后主机模块自动读取刚才写入数据的地址内的数据，将读的的数据与写入数据进行比较，如果正确，主机IP的ERROR信号保持低电平，如果错误，ERROR给出高电平。
本文后面的行为仿真证明：再次给主机IP模块一个txn的触发信号，重新执行4次写入操作+4次读取操作+比较操作。只不过每次触发都从原始基地址开始操作，目标寄存器地址并不增加。
本节的测试工程本着少改动逻辑代码的原则，仍基本采用此逻辑。每次按键触发，执行4次写操作+4次读操作+比对检查操作，增加利用4个LED灯表示每个地址比对结果是否正确（如果正确LED灯亮）。但是当再次按下按钮，LED灯全灭，松开按钮后再执行一组（4次写操作+4次读操作+比对检查）操作，只是新的一组操作地址会递进增加。
2.Zynq系统裁剪
创建工程后，添加一个Zynq IP核，然后调用官方对ZedBoard板中Zynq子系统的默认配置。
得到默认的Zynq硬核配置如下图所示：
对应的Zynq封装如下图所示：
明显看出有很多Zynq中的硬核在本项目中是不需要的，修改配置，将其裁剪掉。
修改后的Zynq配置显示如下：
Zynq的封装图如下所示：
输出端的FCLK_CLK0和FCLK_RESET0_N是输出时钟和复位信号。这两个信号的出处已在前一个图中进行标注。
ZedBoard开发板的ARM端时钟由IC18有源晶振提供33.33333MHz的时钟信号，绑定到Zynq芯片的F7（PS_CLK）管脚上，该管脚是Zynq子系统（PS）的时钟信号。如果工程中添加了Zynq子系统，Vivado会自动将F7绑定到Zynq子系统的PS_CLK管脚上（其实也不需要绑定，这是固话的。F7本身就是专用引脚，但是从硬件结构上也可以看出一个工程只能实例化一个Zynq子系统）。该绑定在约束文件上看不到，而在“Synthesis Design”的“I/O Planning”页面中可以看到。（因为这个管脚是专用管脚，不需要绑定）这里欠个图，后文会有，记着啊！！！
FCLK_CLK0是经过一个时钟管理模块（类似V4中的DCM）生成的，可以修改其参数。Zynq中包含了4个时钟生成模块。配置界面如下：
如果取消勾选，Zynq将不输出时钟信号。
那对于PL端的时序逻辑模块，需要另外寻找时钟信号，在ZedBoard开发板上，IC17有源晶振提供100MHz的GCLK时钟信号，连接到Y9上，可用PL端使用。但是这种方案PS端和PL端由独立的时钟分别驱动，必须考虑跨时钟域问题。
取消FCLK_CLK0的勾选后，Zynq的封装图如下所示：
FCLK_CLK0管脚就没有了，但是FCLK_RESET0_N仍然存在，因为Zynq中的Resets模块是不可配置的。但是Resets有四路输出，为什么这里只有1个呢？是不是跟FCLK_CLKx有绑定呢？
【添加，事后发现，FCLK_RESET0_N也是可以关闭的，操作如下】
太强大的软件了，永远别觉得自己学明白了！！！
为了验证上述疑问，勾选两路FCLK_CLK0和FCLK_CLK2，观察之后的Zynq模块封装如下所示：
没有唤出其余的几路Resets信号。如何召唤其他几路复位信号，还得研究研究。
【个人猜想】：这个FCLK_RESET0_N应该是跟Zynq子系统的复位工作是同步的，有可能Zynq子系统收到复位信号（PS-RST，BTN7，C9，低电平复位）后，FCLK_RESET0_N被拉低，等待一定时间保证Zynq子系统复位完成后，再延时一段时间，再拉高，是的PL端的模块完成复位进入正常工作状态时，Zynq子系统一定已经正常工作。
本项目中，Zynq子系统裁剪完毕后，封装图采用下图方案。
利用FCLK_CLK0驱动PL端的时序逻辑。而将Y9管脚引入的100MHzGCLK信号旁路。
再来看看S_AXI_GP0，即AXI4总线接口（兼容AXI4-Lite）。如下图所示：
终于，画箭头的管脚我们都熟悉了。其他的以后再说。
至此，Zynq子系统我们裁剪完毕了。
【还有个问题】：“DDR3 Controller”硬核在Zynq子系统内部的内存映射还没有看到。打开Address Editor页面，也没有配置信息。
另外，作为从机接口，读写地址总线均为32bits，而不像之前的验证方案，从机的读写地址去掉高位的段地址只留下低位的offset Address，这样的地址接口，能跟PL端的AXI InterConnect匹配吗？
3.PL端主机IP核设计编码
根据之前的经验，利用向导生成一个AXI4-Lite Master IP示例代码，构建主从模块直连的测试系统，从机模块默认内部寄存器数量为4个，构建本仿真系统时，将从机模块内部寄存器数量设置为32个，其余不用修改。
功能仿真文件（详见附录2），模拟连续两次触发txn信号，设置参数，每次txn触发执行两次写读操作，对应的仿真结果如下图所示。
每次txn触发，起始地址均归零，即恢复成初始地址0x4000_0000，写入的数据也变为初始值0xaa00_0000。跟工程设计的逻辑需求不一致。
因此根据需求改造代码逻辑，底层模块的源码详见附录。编码时一定避免Multi-Driver禁告。修改后的逻辑仿真结果如下所示。
可也看出主机模块的功能满足设计要求。
之后将该IP核加入到工程的IP Catalog中。
4.在Block Design中增加PL端IP核
首先在Block Design中实例化一个AzIP_AXI_Master_3的一个IP模块，如下图所示，此时没有连接。
点击页面上的Run Connection Audomation按钮，自动创建连接。整形以后如下图所示。新加的两个模块都是老朋友了，基本逻辑核管脚时序都基本明确了。此时再来看这个连接，基本上就没有问题了。图中用彩色标注出了PL端的时钟信号和复位信号。均由Zynq子系统产生。
同样按F6键检查连接，如果检查无误，表示这个系统的“原理图”画的基本没有问题了。
5.内存映射分析
点击Address Editor标签，看一看，这个图前文在zynq子系统配置完后曾经出现过，但是当时是没有数据的，现在我们放在一起对比一下：
下面我们尝试解读一下，第一幅图时，软件仅仅检测到存在一个AXI Slave接口GP0，当时没有匹配的，所以没有数据，但是当我们加上自行设计的AXI Master接口IP后，软件将二者匹配上了，通过层级结构发现，Zynq上的GP0的Slave接口是匹配用户IP的主机接口的，然后软件自动分配了地址。有一个Base Name，名字是GP0_DDR_LOWOCM，这个名字没看过，不过猜也知道是跟GP0口和DDR相关的，神奇软件怎么知道我想操作DDR呢？猜想应该是配置Zynq时，配置了DDR，所以在Zynq中的总线控制其中激活了DDR相关的段地址，即DDR_LOWCOM。
为了验证上述想法，在Zynq中裁剪掉DDR，具体操作如下：
得到的Zynq封装如下：
可以看到Zynq子系统各种去掉了DDR Control模块，再看Address Editor页面。
可以看到，由于GP0模块的存在，对于Zynq内部总线接口来说，它配置了一个地址GP0_LOW_OCM，关键词是OCM，经过查询，得知OCM的意思是片上存储器（On-Chip Memory），说白了就是内存映射地址。Zynq内部任何一个可配置的外设硬核，其电路均已经硬件实现了，对应的Zynq内部片地址也是固定的，增加外设，应该就会有新的片内地址。
增加了外设USRT1，SD0，USB0，ENET0，QUARD SPI，注意此时没有激活DDR Controller模块。先来看看Zynq的封装。
再来看Address Editor页面
可以看到，对于Quard SPI模块，有单独的地址映射GP0_QSPI_LINEAR，而USRT1，SD0，USB0，ENET0等外设没有，根据Zynq的结构图，大胆猜测，USRT1，SD0，USB0，ENET0等外设均包含在IO Peripherals模块内，因此它们的统一片内地址映射（OCM）的基地址均为GP0_IOP，其中IOP应该就是IO Peripherals的简写。
开始这些数据都没有分配地址，但是前面说了，Zynq中，由于硬件结构都是固定的，剪裁操作是指不激活某些功能模块，个人猜测目的可能是为了低功耗，但是对应的功能模块的内存地址映射都是固定的，跟用户设计的SoC工程无关。
所以这些Zynq内部的映射应该是固定的，我们怎么能够看到呢？点击Address Editor中的Auto Assign Address按钮，如下图所示，系统就会自动填写响应内存映射的Offset Address和Range了。这些都应该是经由GP0路由到这些外设硬核的映射地址。
【补充】LOW_OCM应该就是低速（低性能）存储器地址。有低速对应的肯定就有高速。如下所示。
勾选上图所示项，应该能够打开HIGH_OCM
从上文看出，对于GP0_QSPI_LINEAR和GP0_IOP的命名并没有LOW和OCM等信息。Zynq外设配置不变，仅仅是勾选上图Allow Access to High OCM项，地址映射数据如下。其中HIGH_OCM应该是个独立的内存区域。
去除USRT1，SD0，USB0，ENET0，QUARD SPI等外设，启动DDR Control，仍然勾选Allow Access to High OCM项，得到的Zynq封装如下图：
对应的Address Editor页面如下：
可以看出DDR还是属于LOW_OCM，而HIGH_OCM应该是Zynq系统中的一个特殊区域，具体在哪还不确定，因为跟DDR无关，这里暂时就不关注了。
由于PL中的IP核对Zynq管理的DDR操作是通过地址进行的，因此我们需要对DDR的内存映射整明白。下面再研究研究。
GP0_LOW_OCM已经没有了，但是其对应的地址被包含在GP0_DDR_LOWOCM地址段的低位区间上。
回想《笔记3：PS读写DDR3存储》中的内存映射：
对应的片外DDR3存储芯片的地址的起始位为0x00100000，和这个有点意思。
当然，Address Editor页面中的Offset Address参数和Range参数是可以修改的，而High Address参数是根据前两个参数计算出来的。
必须对Zynq子系统的内存映射原理特别明白，才能正确修改这些参数，因此我们在深入研究研究，看看能不能整明白。
为了深度研究这个问题，在Xilinx Documentation Navigator中搜索OCM，得到如下信息。
可以看到OCM还分为指令OCM和数据OCM。但是这些文件都是比较老的，不是针对Zynq芯片的。没有收获。
上图这些文件也没用，这些讲到都是在PL端用HDL编码实现一个与DDR直接向量的接口控制器的使用方案，而不是设计到Zynq的地址映射方案。
换个思路，查询Zynq的技术文档。
在该文档中得到一些信息，先摘录如下：
Zynq内部有256KB的RAM，就是前面GP0_LOW_OCM或者GP0_HIGH_OCM映射的吗？这个有意思，一定想办法找到。因为之前实验中C语言程序可能就运行在这个内存空间中。
这是前文提到的I/O Peripherals中的内容。
ZedBoard板子用到的芯片是XC7Z020，封装为clg484，但是由于芯片上覆盖了个散热片，不知道是-?。有空问问供货商。
难道是-1？？？可怜啊，CPU主频最高为667MHz。上图应该是从配置文件中获得的，硬件具体是-?其实还是从芯片丝印看最可靠。不过应该差别不会太大，毕竟是通用开发板，不是为了最求性能的。
下面图很重要！
250KB的RAM（OCM)在图中箭头处。
我的猜测，前面出现的内存映射Base Name，应该指的是Central Interconnect的出口，示意图如下：
找到了，就是在这篇文档中，有下列信息：
从上图看到，0x0000_0000是DDR and OCM，
0xFFFC_0000是OCM
那么Zynq内的256KB RAM(OCM)到底怎么访问呢？？？？郁闷
最后的DDR内存映射配置按照系统默认的，如下：
记得主机模块开发是，使用的默认起始地址是0x4000_0000，这个在代码中定义的。不过利用IP核的GUI也能看到。
从前文知道，这个地址是向PL AXI Slave Port #0，即GP0的，Size是1G。
【问题】PL 中的Master IP向0x4000_0000地址写入数据，经过PL中的AXI Interconnect直连，将会转发给GP0，GP0收到后，怎么在转给DDR呢？？？？
【个人猜测】：传入的地址-0x4000_0000，然后进行路由判断吗？假设是这样的，跑起来看看。
至此，本实验的硬件设计完毕。保存后，退出Block Design页面。
6.封装 & Synthesis
然后记得创建HDL Wrapper，
之后对这个工程进行Run Synthesis。
结果没有error和critical warning。
7.行为仿真
原想对这个包含Zynq的顶层模块进行行为仿真，但是看了一眼端口定义。
跟DDR相关的接口时序我根本没法设定，故此放弃了。
直接下板测试吧。
8.管脚绑定
综合完成后，进入Synthesized Design页面，先看看Schematic
然后重点看I/O Planning
根据原理图，PS_CLK（F7）和PS_POR_B(B5)是在Bank500上，驱动电压是3.3V，而PS_RST(C9)是在Bank501上，驱动电压是1.8V。但是这几项是Fixed，改不了，就这样吧。
只能绑定用户管脚，最后的配置图如下：
之后会创建约束文件。
之后，执行Run Implementation和Generate Bitstream。
9.是否还需要启用SDK
直接下板尝试。
没有反应啊。郁闷！Why？？？？
时序逻辑没反应，先检查时钟信号和复位信号，在本实验系统中，PL端的时钟信号和复位信号均是从Zynq子系统中输出的，因此对工程做如下改变，将时钟信号和复位信号引到板上的LED灯处，用于显示和测量。
该工程Synthesis & Implementation后，仍然通过Hardware Manager下载后，现象为FCLK_CLK0驱动的LED灯常亮，使用示波器检测输出为持续高电平，FCLK_RESET0_N驱动的LED灯不亮。根据现象猜测，Zynq子系统中的时钟单元没有正常工作。
原因分析（个人观点）：因为Zynq其实是一个ARM系统，其内部的硬核要想按照配置正常工作，应该是在初始化阶段对相应硬核的控制寄存器进行初始化配置，如果是使用Hardware Manager下载是无法操作这一步的。因此尝试使用SDK进行SoC工程配置。
10.是否还需要启用SDK
根据之前的学习，使用SDK有下列几步，不清楚的参看之间的学习笔记。
第一步：Vivado中Export Hardware...(其中需要Include Bitstream)
第二步：Vivado中Launch SDK
第三步：SDK中创建板载支持库函数，Board Support Package
第四步：创建用户工程，Application Project
第五步：编译
第六步：Program FPGA
下面对其中跟本实验有关的进行简单说明
（1）在第三步中，启用SDK可以看到内存映射信息，跟内存相关的一个是DDR，一个是Zynq系统内部的RAM，内存地址如下，根据标题分析，应该是Zynq子系统内部，对于CPU来说的地址设定。
个人猜测：从上图可以看出在Zynq内部，对于两个CPU Core，同一个硬核，操作地址是相同的，从而能够实现双核的数据交互。比如ps7_cortexa9_0能够直接对0x0010_0000的DDR读写数据，同样的ps7_cortexa9_1也可以对该地址的DDR直接读写数据。同时这将会带来一个问题就是同步。另外，还有个问题就是如果是双核运行，每个核都将有自己独立的代码段和栈空间（这两个空间是程序运行时系统使用的，用户不能强行进行读写操作），而堆空间是用户自行申请使用的内存空间，通常用来进行用户数据存储，也就是说堆空间才是双core可以公用的。而无论代码段、栈空间、堆空间的物理载体都是内存（RAM or DDR），因此c语言嵌入式程序对物理内存直接读写时，要避免对代码段和栈空间的地址进行操作。而对代码段和栈空间的配置应该是在编译过程中的link阶段配置的。具体配置接口如下：
这是配置界面，与传统ARM开发对应的配置文件如下所示，相应的详细原理参考传统ARM开发的相关知识。
（2）对Zynq子系统中各个硬核的初始化配置。
前面分析过，对于Zynq子系统，在不使用CPU Core的架构设计中，如果仅仅使用HardWare下载，Zynq子系统内部的外设硬核也是不能正常工作的。前面分析认为是没有进行初始化配置，在SDK软件中，打开ps7_init.tcl文件如下图所示，从名字可以看出，这是一个初始化的脚本配置文件，既然是tcl文件，应该就不需要c语言调用，而是直接配置，下面截图可以看出是对PLL硬核，Clock硬核、DDR硬核控制寄存器的初始化配置。
其中猜测：mask_write 0XF8000008 0x0000FFFF 0x0000DF0D
应该表示的是向0xF800_0008地址写入数据0x0000_ffff_0000_df0f(共计32bits)
在Run时，SDK软件会在配置“Run ps7_init”项对应的逻辑状态下自动调用该tcl文件完成初始化操作的。
（3）在第四步创建用户工程（Application Project）时，如果还按照之前的经验选择“Hello World”，将会显示如下信息：
提示信息为:目前硬件项目设计中没有Uart外设硬核，因此该示例不能创建，真丢本实验，仅有Peripheral Tests和Empty Application两项可以使用。经过验证，利用这两个模版都可以实现实验要求，这里只介绍Empty Application模版
使用Empty Application模版，创建的工程如下所示：
可以看出并没有任何c语言文件。
在src中创建一个c语言文件main.c（文件名可以随便起），其中自行输入一个main函数（必须是这个函数名），保存后，SDK会自动编译，生成一个debug文件和binaries项。
可以看出，这里main函数里什么都没有做。
【补充】对内存分配的进一步分析研究
双击Binaries下的elf文件，显示如下信息：
可以看出，编译完成之后，编译软件对嵌入式程序进行的内存划分。而且系统空间大小地址都分配在ddr的低地址区间，因本实验测试时，选用的DDR地址空间应以高地址空间为宜。
在详细分析elf文件中对内存的划分，重点看下图部分。
编译软件分析完毕后，得到的栈空间其实地址为0010_a030，栈空间大小为0000_3800(14K Bytes)。(0010_a030+0000_3800=0010_d830)
c语言嵌入式软件中，如果不是直接地址操作，本实验编译后的软件使用的数据空间为：0010_0000~0010_d830，空间大小为：54.046875K Bytes。
因此，本实验中对DDR的内存读写测试，测试的内存地址区间从0020_0000开始为宜。
另外前文分析时说过，板载DDR为512MB，但是在vivado生成的system.hdf文件中，定义的ps7_ddr_0的内存空间范围只有511MB，少了1MB，当时不知道这1MB时怎么被贪污的。
【个人猜测】但是再看elf文件，可以看到0000_0000开始的空间，是用来进行Debug调试的，因此被Vivado+SDK系统给扣下了，对用户不可见。
创建完用户逻辑后，配置Run As...项，用于下载程序。
其中，Run Configurations页面前面已经见过很多次，这次重点说明的地方已经框出：
其中“Reset Processor”仅仅时重新下载C语言嵌入式程序，download to processor
当选中“Reset Entire System”项，会先下载PL端的bit文件，然后再下载C语言嵌入式程序，download to processor。
具体说明如下所示。
选择reset processor项后，run成功，SDK Log窗口显示如下信息，可以看出，先执行ps_init.tcl脚本，配置PS的硬核，在运行ps7_post_config(具体工作内容还没整明白)，然后复位ps7_cortexa9_0（是的c语言程序从main函数开始运行）。
在开发板上，程序下载成功后，如果按BTN6(PROG)，相当于Program FPGA这一项需要重做。因此开发板不再有反应。
在开发板上，程序下载成功后，如果按BTN9(PS-RST)，相当于zynq子系统复位，而非CPU（ps7_cortexa9_0）复位，此时需要重新执行Run ps7_init这一项。因此开发板不再有反应。
【结果】下载成功后，开发板反应如设计所示。实验结果表明：
当设置PL端的Master设备访问的地址为0x4020_0000(0x4000_0000为32b GP AXI Slave Port的地址 + 0x0020_0000为DDR内的地址)时，下板运行结果表明内存读写操作是失败的。
当设置PL端的Master设备访问的地址为0x0020_0000(为Zynq子系统内CPU对DDR访问的地址段)时，下板运行结果表明内存读写操作是成功的。
【结论】：
1. 只要SoC系统中，用到了Zynq子系统，无论逻辑上是否激活CPU，都需要使用SDK进行下载，原因时初始化Zynq子系统中硬核。
2. PL端对Zynq子系统中的寄存器进行操作，不需要考虑进行二次内存封装，直接使用Zynq内设定的地址即可。即整个芯片PL+PS是采用统一地址映射的。
【后继】
本实验的最初需求设计，只能保证PL端的Master IP核对Zynq子系统中的内存地址空间读写是正确的，而不能保证一定是读写到了DDR，因此下一个实验，计划利用PL端的Master IP核向0x0020_0000起始的地址端空间写入数据，而用CPU从相应的地址读取数据，进而验证上述结论第二条是否真的是那样的。
附录1：主机IP核底层模块代码
`timescale 1 ns / 1 ps
module AzIP_AXI_Master_3_v1_0_M00_AXI #
(
// Users to add parameters here
// User parameters ends
// Do not modify the parameters beyond this line
// The master will start generating data from the C_M_START_DATA_VALUE value
parameter C_M_START_DATA_VALUE = 32'hAA000000,
// The master requires a target slave base address.
// The master will initiate read and write transactions on the slave with base address specified here as a parameter.
parameter C_M_TARGET_SLAVE_BASE_ADDR = 32'h40000000,
// Width of M_AXI address bus.
// The master generates the read and write addresses of width specified as C_M_AXI_ADDR_WIDTH.
parameter integer C_M_AXI_ADDR_WIDTH = 32,
// Width of M_AXI data bus.
// The master issues write data and accept read data where the width of the data bus is C_M_AXI_DATA_WIDTH
parameter integer C_M_AXI_DATA_WIDTH = 32,
// Transaction number is the number of write
// and read transactions the master will perform as a part of this example memory test.
parameter integer C_M_TRANSACTIONS_NUM = 4
)
(
// Users to add ports here
output reg [3:0] flag_opr, // 输出每次写读操作的对比结果，正确输出高电平
// User ports ends
// Do not modify the ports beyond this line
// Initiate AXI transactions
input wire INIT_AXI_TXN,
// Asserts when ERROR is detected
output reg ERROR,
// Asserts when AXI transactions is complete
output wire TXN_DONE,
// AXI clock signal
input wire M_AXI_ACLK,
// AXI active low reset signal
input wire M_AXI_ARESETN,
// Master Interface Write Address Channel ports. Write address (issued by master)
output wire [C_M_AXI_ADDR_WIDTH-1 : 0] M_AXI_AWADDR,
// Write channel Protection type.
// This signal indicates the privilege and security level of the transaction,
// and whether the transaction is a data access or an instruction access.
output wire [2 : 0] M_AXI_AWPROT,
// Write address valid.
// This signal indicates that the master signaling valid write address and control information.
output wire M_AXI_AWVALID,
// Write address ready.
// This signal indicates that the slave is ready to accept an address and associated control signals.
input wire M_AXI_AWREADY,
// Master Interface Write Data Channel ports. Write data (issued by master)
output wire [C_M_AXI_DATA_WIDTH-1 : 0] M_AXI_WDATA,
// Write strobes.
// This signal indicates which byte lanes hold valid data.
// There is one write strobe bit for each eight bits of the write data bus.
output wire [C_M_AXI_DATA_WIDTH/8-1 : 0] M_AXI_WSTRB,
// Write valid. This signal indicates that valid write data and strobes are available.
output wire M_AXI_WVALID,
// Write ready. This signal indicates that the slave can accept the write data.
input wire M_AXI_WREADY,
// Master Interface Write Response Channel ports.
// This signal indicates the status of the write transaction.
input wire [1 : 0] M_AXI_BRESP,
// Write response valid.
// This signal indicates that the channel is signaling a valid write response
input wire M_AXI_BVALID,
// Response ready. This signal indicates that the master can accept a write response.
output wire M_AXI_BREADY,
// Master Interface Read Address Channel ports. Read address (issued by master)
output wire [C_M_AXI_ADDR_WIDTH-1 : 0] M_AXI_ARADDR,
// Protection type.
// This signal indicates the privilege and security level of the transaction,
// and whether the transaction is a data access or an instruction access.
output wire [2 : 0] M_AXI_ARPROT,
// Read address valid.
// This signal indicates that the channel is signaling valid read address and control information.
output wire M_AXI_ARVALID,
// Read address ready.
// This signal indicates that the slave is ready to accept an address and associated control signals.
input wire M_AXI_ARREADY,
// Master Interface Read Data Channel ports. Read data (issued by slave)
input wire [C_M_AXI_DATA_WIDTH-1 : 0] M_AXI_RDATA,
// Read response. This signal indicates the status of the read transfer.
input wire [1 : 0] M_AXI_RRESP,
// Read valid. This signal indicates that the channel is signaling the required read data.
input wire M_AXI_RVALID,
// Read ready. This signal indicates that the master can accept the read data and response information.
output wire M_AXI_RREADY
);
// function called clogb2 that returns an integer which has the
// value of the ceiling of the log base 2
function integer clogb2 (input integer bit_depth);
begin
for(clogb2=0; bit_depth>0; clogb2=clogb2+1)
bit_depth = bit_depth >> 1;
end
endfunction
// TRANS_NUM_BITS is the width of the index counter for
// number of write or read transaction.
localparam integer TRANS_NUM_BITS = clogb2(C_M_TRANSACTIONS_NUM-1);
// Example State machine to initialize counter, initialize write transactions,
// initialize read transactions and comparison of read data with the
// written data words.
parameter [1:0] IDLE = 2'b00, // This state initiates AXI4Lite transaction
// after the state machine changes state to INIT_WRITE
// when there is 0 to 1 transition on INIT_AXI_TXN
INIT_WRITE = 2'b01, // This state initializes write transaction,
// once writes are done, the state machine
// changes state to INIT_READ
INIT_READ = 2'b10, // This state initializes read transaction
// once reads are done, the state machine
// changes state to INIT_COMPARE
INIT_COMPARE = 2'b11; // This state issues the status of comparison
// of the written data with the read data
reg [1:0] mst_exec_state;
// AXI4LITE signals
//write address valid
reg axi_awvalid;
//write data valid
reg axi_wvalid;
//read address valid
reg axi_arvalid;
//read data acceptance
reg axi_rready;
//write response acceptance
reg axi_bready;
//write address
reg [C_M_AXI_ADDR_WIDTH-1 : 0] axi_awaddr;
//write data
reg [C_M_AXI_DATA_WIDTH-1 : 0] axi_wdata;
//read addresss
reg [C_M_AXI_ADDR_WIDTH-1 : 0] axi_araddr;
//Asserts when there is a write response error
wire write_resp_error;
//Asserts when there is a read response error
wire read_resp_error;
//A pulse to initiate a write transaction
reg start_single_write;
//A pulse to initiate a read transaction
reg start_single_read;
//Asserts when a single beat write transaction is issued and remains asserted till the completion of write trasaction.
reg write_issued;
//Asserts when a single beat read transaction is issued and remains asserted till the completion of read trasaction.
reg read_issued;
//flag that marks the completion of write trasactions. The number of write transaction is user selected by the parameter C_M_TRANSACTIONS_NUM.
reg writes_done;
//flag that marks the completion of read trasactions. The number of read transaction is user selected by the parameter C_M_TRANSACTIONS_NUM
reg reads_done;
//The error register is asserted when any of the write response error, read response error or the data mismatch flags are asserted.
reg error_reg;
//index counter to track the number of write transaction issued
reg [TRANS_NUM_BITS : 0] write_index;
//index counter to track the number of read transaction issued
reg [TRANS_NUM_BITS : 0] read_index;
//Expected read data used to compare with the read data.
reg [C_M_AXI_DATA_WIDTH-1 : 0] expected_rdata;
//Flag marks the completion of comparison of the read data with the expected read data
reg compare_done;
//This flag is asserted when there is a mismatch of the read data with the expected read data.
reg read_mismatch;
//Flag is asserted when the write index reaches the last write transction number
reg last_write;
//Flag is asserted when the read index reaches the last read transction number
reg last_read;
reg init_txn_ff;
reg init_txn_ff2;
reg init_txn_edge;
wire init_txn_pulse;
reg [7:0] rs_test_data_w_count; // 写入数据递增计数器
reg [7:0] rs_test_data_c_count; // 数据对比计数器
reg r_flag;
// I/O Connections assignments
//Adding the offset address to the base addr of the slave
assign M_AXI_AWADDR = C_M_TARGET_SLAVE_BASE_ADDR + axi_awaddr;
//AXI 4 write data
assign M_AXI_WDATA = axi_wdata;
assign M_AXI_AWPROT = 3'b000;
assign M_AXI_AWVALID = axi_awvalid;
//Write Data(W)
assign M_AXI_WVALID = axi_wvalid;
//Set all byte strobes in this example
assign M_AXI_WSTRB = 4'b1111;
//Write Response (B)
assign M_AXI_BREADY = axi_bready;
//Read Address (AR)
assign M_AXI_ARADDR = C_M_TARGET_SLAVE_BASE_ADDR + axi_araddr;
assign M_AXI_ARVALID = axi_arvalid;
assign M_AXI_ARPROT = 3'b001;
//Read and Read Response (R)
assign M_AXI_RREADY = axi_rready;
//Example design I/O
assign TXN_DONE = compare_done;
assign init_txn_pulse = (!init_txn_ff2) && init_txn_ff; //原代码时上升沿触发
//Generate a pulse to initiate AXI transaction.
always @(posedge M_AXI_ACLK)
begin
// Initiates AXI transaction delay
if (M_AXI_ARESETN == 0 )
begin
init_txn_ff <= 1'b0;
init_txn_ff2 <= 1'b0;
end
else
begin
init_txn_ff <= INIT_AXI_TXN;
init_txn_ff2 <= init_txn_ff;
end
end
//--------------------
//Write Address Channel
//--------------------
// The purpose of the write address channel is to request the address and
// command information for the entire transaction. It is a single beat
// of information.
// Note for this example the axi_awvalid/axi_wvalid are asserted at the same
// time, and then each is deasserted independent from each other.
// This is a lower-performance, but simplier control scheme.
// AXI VALID signals must be held active until accepted by the partner.
// A data transfer is accepted by the slave when a master has
// VALID data and the slave acknoledges it is also READY. While the master
// is allowed to generated multiple, back-to-back requests by not
// deasserting VALID, this design will add rest cycle for
// simplicity.
// Since only one outstanding transaction is issued by the user design,
// there will not be a collision between a new request and an accepted
// request on the same clock cycle.
always @(posedge M_AXI_ACLK)
begin
//Only VALID signals must be deasserted during reset per AXI spec
//Consider inverting then registering active-low reset for higher fmax
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
begin
axi_awvalid <= 1'b0;
end
//Signal a new address/data command is available by user logic
else
begin
if (start_single_write)
begin
axi_awvalid <= 1'b1;
end
//Address accepted by interconnect/slave (issue of M_AXI_AWREADY by slave)
else if (M_AXI_AWREADY && axi_awvalid)
begin
axi_awvalid <= 1'b0;
end
end
end
// start_single_write triggers a new write
// transaction. write_index is a counter to
// keep track with number of write transaction
// issued/initiated
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
begin
write_index <= 0;
if (M_AXI_ARESETN == 0) begin
rs_test_data_w_count <= 8'h00;
end
else if (init_txn_pulse == 1'b1) begin
rs_test_data_w_count <= rs_test_data_w_count;
end
end
// Signals a new write address/ write data is
// available by user logic
else if (start_single_write)
begin
write_index <= write_index + 1;
rs_test_data_w_count <= rs_test_data_w_count+1;
end
end
//--------------------
//Write Data Channel
//--------------------
//The write data channel is for transfering the actual data.
//The data generation is speific to the example design, and
//so only the WVALID/WREADY handshake is shown here
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
begin
axi_wvalid <= 1'b0;
end
//Signal a new address/data command is available by user logic
else if (start_single_write)
begin
axi_wvalid <= 1'b1;
end
//Data accepted by interconnect/slave (issue of M_AXI_WREADY by slave)
else if (M_AXI_WREADY && axi_wvalid)
begin
axi_wvalid <= 1'b0;
end
end
//----------------------------
//Write Response (B) Channel
//----------------------------
//The write response channel provides feedback that the write has committed
//to memory. BREADY will occur after both the data and the write address
//has arrived and been accepted by the slave, and can guarantee that no
//other accesses launched afterwards will be able to be reordered before it.
//The BRESP bit [1] is used indicate any errors from the interconnect or
//slave for the entire write burst. This example will capture the error.
//While not necessary per spec, it is advisable to reset READY signals in
//case of differing reset latencies between master/slave.
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
begin
axi_bready <= 1'b0;
end
// accept/acknowledge bresp with axi_bready by the master
// when M_AXI_BVALID is asserted by slave
else if (M_AXI_BVALID && ~axi_bready)
begin
axi_bready <= 1'b1;
end
// deassert after one clock cycle
else if (axi_bready)
begin
axi_bready <= 1'b0;
end
// retain the previous value
else
axi_bready <= axi_bready;
end
//Flag write errors
assign write_resp_error = (axi_bready & M_AXI_BVALID & M_AXI_BRESP[1]);
//----------------------------
//Read Address Channel
//----------------------------
//start_single_read triggers a new read transaction. read_index is a counter to
//keep track with number of read transaction issued/initiated
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
begin
read_index <= 0;
if (M_AXI_ARESETN == 0) begin
rs_test_data_c_count <= 8'h00;
end
else if (init_txn_pulse == 1'b1) begin
rs_test_data_c_count <= rs_test_data_c_count;
end
end
// Signals a new read address is
// available by user logic
else if (start_single_read)
begin
read_index <= read_index + 1;
rs_test_data_c_count <= rs_test_data_c_count+1;
end
end
// A new axi_arvalid is asserted when there is a valid read address
// available by the master. start_single_read triggers a new read
// transaction
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
begin
axi_arvalid <= 1'b0;
end
//Signal a new read address command is available by user logic
else if (start_single_read)
begin
axi_arvalid <= 1'b1;
end
//RAddress accepted by interconnect/slave (issue of M_AXI_ARREADY by slave)
else if (M_AXI_ARREADY && axi_arvalid)
begin
axi_arvalid <= 1'b0;
end
// retain the previous value
end
//--------------------------------
//Read Data (and Response) Channel
//--------------------------------
//The Read Data channel returns the results of the read request
//The master will accept the read data by asserting axi_rready
//when there is a valid read data available.
//While not necessary per spec, it is advisable to reset READY signals in
//case of differing reset latencies between master/slave.
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
begin
axi_rready <= 1'b0;
end
// accept/acknowledge rdata/rresp with axi_rready by the master
// when M_AXI_RVALID is asserted by slave
else if (M_AXI_RVALID && ~axi_rready)
begin
axi_rready <= 1'b1;
end
// deassert after one clock cycle
else if (axi_rready)
begin
axi_rready <= 1'b0;
end
// retain the previous value
end
//Flag write errors
assign read_resp_error = (axi_rready & M_AXI_RVALID & M_AXI_RRESP[1]);
//--------------------------------
//User Logic
//--------------------------------
//Address/Data Stimulus
//Address/data pairs for this example. The read and write values should
//match.
//Modify these as desired for different address patterns.
//Write Addresses
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
begin
if (M_AXI_ARESETN == 0) begin
axi_awaddr <= 0;
end
else if (init_txn_pulse == 1'b1) begin
axi_awaddr <= axi_awaddr;
end
end
// Signals a new write address/ write data is
// available by user logic
else if (M_AXI_AWREADY && axi_awvalid)
begin
axi_awaddr <= axi_awaddr + 32'h00000004;
end
end
// Write data generation
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1 )
begin
if (M_AXI_ARESETN == 0) begin
axi_wdata <= C_M_START_DATA_VALUE;
end
else if (init_txn_pulse == 1'b1) begin
axi_wdata <= axi_wdata;
end
end
// Signals a new write address/ write data is
// available by user logic
else if (M_AXI_WREADY && axi_wvalid)
begin
axi_wdata <= C_M_START_DATA_VALUE + rs_test_data_w_count;
end
end
//Read Addresses
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
begin
if (M_AXI_ARESETN == 0) begin
axi_araddr <= 0;
end
else if (init_txn_pulse == 1'b1) begin
axi_araddr <= axi_araddr;
end
end
// Signals a new write address/ write data is
// available by user logic
else if (M_AXI_ARREADY && axi_arvalid)
begin
axi_araddr <= axi_araddr + 32'h00000004;
end
end
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
begin
if (M_AXI_ARESETN == 0) begin
expected_rdata <= C_M_START_DATA_VALUE;
end
else if (init_txn_pulse == 1'b1) begin
expected_rdata <= expected_rdata;
end
end
// Signals a new write address/ write data is
// available by user logic
else if (M_AXI_RVALID && axi_rready)
begin
expected_rdata <= C_M_START_DATA_VALUE + rs_test_data_c_count;
end
end
//implement master command interface state machine
always @ ( posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 1'b0)
begin
// reset condition
// All the signals are assigned default values under reset condition
mst_exec_state <= IDLE;
start_single_write <= 1'b0;
write_issued <= 1'b0;
start_single_read <= 1'b0;
read_issued <= 1'b0;
compare_done <= 1'b0;
ERROR <= 1'b0;
end
else
begin
// state transition
case (mst_exec_state)
IDLE:
// This state is responsible to initiate
// AXI transaction when init_txn_pulse is asserted
if ( init_txn_pulse == 1'b1 )
begin
mst_exec_state <= INIT_WRITE;
ERROR <= 1'b0;
compare_done <= 1'b0;
end
else
begin
mst_exec_state <= IDLE;
end
INIT_WRITE:
// This state is responsible to issue start_single_write pulse to
// initiate a write transaction. Write transactions will be
// issued until last_write signal is asserted.
// write controller
if (writes_done)
begin
mst_exec_state <= INIT_READ;//
end
else
begin
mst_exec_state <= INIT_WRITE;
if (~axi_awvalid && ~axi_wvalid && ~M_AXI_BVALID && ~last_write && ~start_single_write && ~write_issued)
begin
start_single_write <= 1'b1;
write_issued <= 1'b1;
end
else if (axi_bready)
begin
write_issued <= 1'b0;
end
else
begin
start_single_write <= 1'b0; //Negate to generate a pulse
end
end
INIT_READ:
// This state is responsible to issue start_single_read pulse to
// initiate a read transaction. Read transactions will be
// issued until last_read signal is asserted.
// read controller
if (reads_done)
begin
mst_exec_state <= INIT_COMPARE;
end
else
begin
mst_exec_state <= INIT_READ;
if (~axi_arvalid && ~M_AXI_RVALID && ~last_read && ~start_single_read && ~read_issued)
begin
start_single_read <= 1'b1;
read_issued <= 1'b1;
end
else if (axi_rready)
begin
read_issued <= 1'b0;
end
else
begin
start_single_read <= 1'b0; //Negate to generate a pulse
end
end
INIT_COMPARE:
begin
// This state is responsible to issue the state of comparison
// of written data with the read data. If no error flags are set,
// compare_done signal will be asseted to indicate success.
ERROR <= error_reg;
mst_exec_state <= IDLE;
compare_done <= 1'b1;
end
default :
begin
mst_exec_state <= IDLE;
end
endcase
end
end //MASTER_EXECUTION_PROC
//Terminal write count
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
last_write <= 1'b0;
//The last write should be associated with a write address ready response
else if ((write_index == C_M_TRANSACTIONS_NUM) && M_AXI_AWREADY)
last_write <= 1'b1;
else
last_write <= last_write;
end
//Check for last write completion.
//This logic is to qualify the last write count with the final write
//response. This demonstrates how to confirm that a write has been
//committed.
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
writes_done <= 1'b0;
//The writes_done should be associated with a bready response
else if (last_write && M_AXI_BVALID && axi_bready)
writes_done <= 1'b1;
else
writes_done <= writes_done;
end
//------------------
//Read example
//------------------
//Terminal Read Count
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
last_read <= 1'b0;
//The last read should be associated with a read address ready response
else if ((read_index == C_M_TRANSACTIONS_NUM) && (M_AXI_ARREADY) )
last_read <= 1'b1;
else
last_read <= last_read;
end
/*
Check for last read completion.
This logic is to qualify the last read count with the final read
response/data.
*/
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
reads_done <= 1'b0;
//The reads_done should be associated with a read ready response
else if (last_read && M_AXI_RVALID && axi_rready)
reads_done <= 1'b1;
else
reads_done <= reads_done;
end
//-----------------------------
//Example design error register
//-----------------------------
//Data Comparison
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || INIT_AXI_TXN == 1'b0) begin
read_mismatch <= 1'b0;
flag_opr <= 4'h0;
r_flag <= 1'b0;
end
//The read data when available (on axi_rready) is compared with the expected data
else if (M_AXI_RVALID && axi_rready) begin
r_flag <= 1'b1;
if (M_AXI_RDATA != expected_rdata) begin
read_mismatch <= 1'b1;
case (read_index-1)
2'b00: flag_opr[0] <= 1'b0;
2'b01: flag_opr[1] <= 1'b0;
2'b10: flag_opr[2] <= 1'b0;
2'b11: flag_opr[3] <= 1'b0;
endcase
end
else begin
read_mismatch <= read_mismatch;
case (read_index-1)
2'b00: flag_opr[0] <= 1'b1;
2'b01: flag_opr[1] <= 1'b1;
2'b10: flag_opr[2] <= 1'b1;
2'b11: flag_opr[3] <= 1'b1;
endcase
end
end
else begin
r_flag <= 1'b0;
end
end
// Register and hold any data mismatches, or read/write interface errors
always @(posedge M_AXI_ACLK)
begin
if (M_AXI_ARESETN == 0 || init_txn_pulse == 1'b1)
error_reg <= 1'b0;
//Capture any error types
else if (read_mismatch || write_resp_error || read_resp_error)
error_reg <= 1'b1;
else
error_reg <= error_reg;
end
// Add user logic here
// User logic ends
endmodule
附录2：主从机直连测试系统行为仿真文件
`timescale 1ns / 1ps
module Sim_AXI4_Lite_Direct_Connect();
reg axi_ACLK; // AXI总线时钟
reg axi_ARESETn; // 系统复位信号，低电平有效
reg r_app_txn; // 应用级复位信号，负脉冲，上升沿复位
wire w_err; // 状态指示，异常
wire w_txn_done; // 状态指示，发送完毕
wire [3:0] w_flag_opr;
Top_AXI4_Lite_Direct_Connect # (
.C_AXI_START_DATA_VALUE(32'hAA000000),
.C_AXI_TARGET_SLAVE_BASE_ADDR(32'h40000000),
.C_AXI_ADDR_WIDTH(32),
.C_AXI_DATA_WIDTH(32),
.C_AXI_TRANSACTIONS_NUM(4) // 一次触发读写次数，不能大于4
) Ut1 (
.axi_ACLK(axi_ACLK),
.axi_ARESETn(axi_ARESETn),
.app_TXn(r_app_txn),
.state_err(w_err),
.state_done(w_txn_done),
.flag_opr(w_flag_opr)
);
parameter PERIOD = 2;
always begin
#(PERIOD/2);
axi_ACLK = ~axi_ACLK;
end
initial begin
axi_ACLK = 1'b0;
axi_ARESETn = 1'b1;
r_app_txn = 1'b1;
#(4*PERIOD);
axi_ARESETn = 1'b0;
#(1*PERIOD);
r_app_txn = 1'b0;
#(2*PERIOD);
axi_ARESETn = 1'b1;
#(2*PERIOD);
r_app_txn = 1'b1;
#(58*PERIOD);
r_app_txn = 1'b0;
#(3*PERIOD);
r_app_txn = 1'b1;
end
endmodule