ZYNQ 使用AXI_BRAM实现PS与PL 数据交互数据交互
一，有时 CPU 需要与 PL 进行小批量的数据交换，可以通过 Block RAM 实现。通过 Zynq 的 GP Master 接口读写 PL 端的 BRAM，实现PS与 PL 的交互。加入自定义的 FPGA 程序，并利用 AXI4 总线进行配置，通知何时读写 BRAM。CPU 通过 AXI BRAM Controller 读取 BRAM 数据，CPU 仅配置自定义的 PL BRAM Controller 的寄存器，不通过它读写数据。
1、AXI总线、AXI接口、AXI协议
总线是一组传输通道，是各种逻辑器件构成的传输数据的通道；接口是一种连接标准，又常被称为物理接口；协议是数据传输的规则。PS与PL连接方式主要是通过AXI总线进行的。ZYNQ上的总线协议有AXI4, AXI4-Lite, AXI4-Stream三种总线协议。而PS与PL之间的接口（AXI-GP、AXI-HP、AXI-ACP）只支持AXI4与AXI4-Lite这两种总线协议。
2、BRAM介绍
Block RAM是PL部分的存储器阵列，就相当于在PL中开辟一片空间来存储数据，通过端口来进行读写。
BRAM设置模式：
单端口：通过一个端口对BRAM进行读写。
简单双端口：有两个端口连接到BRAM，一个端口只读，一个端口只写
真双端口：两个端口都可以对BRAM进行读写。
3，如何选择：
（1）较大的存储应用，建议用BRAM；零星的小RAM，一般就用DRAM。（小于或等于64bit容量的用分布式实现，深度在64~128之间的，若无额外的block可用分布式RAM。数据宽度大于16时用Block RAM）
（2）dram可以是纯组合逻辑，即给出地址马上出数据，也可以加上register变成有时钟的ram。而bram一定是有时钟的。（要求异步读取就使用分布式RAM）
（3）如果要产生大的FIFO或timing要求较高，就用Block RAM。否则，就可以用Distributed RAM。块RAM是比较大块的RAM，即使用了它的一小部分，那么整个Block RAM就不能再用了。所以，当你要用的RAM比较小，时序要求不高时，可以用分布式RAM，节省资源。FPGA中的资源位置是固定的，例如BRAM就是一列一列分布的（存储器阵列），会产生较大的布线时延。在大规模FPGA中，如果用光所有的BRAM，性能一般会下降，甚至出现route不通的情况，就是这个原因。
（4）用户申请存储资源，FPGA先提供Block RAM ，当Block RAM 数量不够时再用分布式RAM补充。
二，vivado工程：添加了 GPIO 产生中断，中断是在 pl_ram_ctrl 写完 BRAM后发出 write_end 信号给 GPIO，GPIO 产生中断。
1，以下为 AXI BRAM Controller 模块配置，连接 AXI 总线，可用于读写 BRAM 模块，AXI 模式设置为 AXI4，数据宽度设置为 32 位，memory depth 不在这里设置，需要在 Address Editor 里设置。BRAM 端口数量设置为 1 个，用于连接双口 RAM 的 PORTA，不使能 ECC 功能。
由于 AXI4 总线为字节询址，BRAM 数据宽度设置也是 32 位，同样都是 32 位数据宽度，因此在映射到 BRAM 地址时，需要按 4 字节询址，即去掉最后两位，下图为 BRAM 控制器与 BRAM的映射关系。
在 Address Editor 里选择 BRAM 询址大小，如设置 4K 空间，即可询址 BRAM 空间为 1K 深度。不要随意更改地址，因为其它地址可能被其他设备占用了，axi_bram_ctrl_0 0x40000000 ， pl_ram_ctrl_0 0x43C00000。
2，BRAM 设置如下，有两种模式选择，standalon 模式，此模式可以自由配置 RAM 的数据宽度和深度。BRAM Controller 模式，此模式下地址线和数据端口默认为 32 位，本实验因为用到了 BRAM 控制器，因此选择 BRAM Controller 模式。Memory 类型选择双口 RAM，一端连 BRAM控制器，一端连 PL RAM 控制器。
3，添加自定义的 PL RAM 控制器 pl_ram_ctrl，功能很简单，start 信号有效后开始读取 BRAM 的数据，可通过 ILA 逻辑分析仪观察读取的数据，PL RAM 控制器读 BRAM 结束后，开始向 BRAM写数据，写完数据使能 write_end 信号，通过 GPIO 产生中断，CPU 即可读取 BRAM 的数据。将 PL 控制器信号与 BRAM 的 PORTB 连接。代码如下，如果想添加自定义 IP 到 IP 库中，点击 IP Catalog，在 Vivado Repository 右键点击 Add Repository。
module ram_read_write
(
input clk,
input rst_n,
input [31:0] din,
output reg [31:0] dout,
output reg en,
output reg [3:0] we,
output rst,
output reg [31:0] addr,
input start,
input [31:0] init_data,
output reg start_clr,
output reg write_end,
input [31:0] len,
input [31:0] start_addr
);
assign rst = 1'b0 ;
localparam IDLE = 3'd0 ;
localparam READ_RAM = 3'd1 ;
localparam READ_END = 3'd2 ;
localparam WRITE_RAM = 3'd3 ;
localparam WRITE_END = 3'd4 ;
reg [2:0] state ;
reg [31:0] len_tmp ;
reg [31:0] start_addr_tmp ;
//write part
always @(posedge clk or negedge rst_n)
begin
if (~rst_n)
begin
state <= IDLE ;
dout <= 32'd0 ;
en <= 1'b0 ;
we <= 4'd0 ;
addr <= 32'd0 ;
write_end <= 1'b0 ;
start_clr <= 1'b0 ;
len_tmp <= 32'd0 ;
start_addr_tmp <= 32'd0 ;
end
else
begin
case(state)
IDLE : begin
if (start)
begin
state <= READ_RAM ;
addr <= start_addr ;
start_addr_tmp <= start_addr ;
len_tmp <= len ;
dout <= init_data ;
en <= 1'b1 ;
start_clr <= 1'b1 ;
end
write_end <= 1'b0 ;
end
READ_RAM : begin
if ((addr - start_addr_tmp) == len_tmp - 4)
begin
state <= READ_END ;
en <= 1'b0 ;
end
else
begin
addr <= addr + 32'd4 ;
end
start_clr <= 1'b0 ;
end
READ_END : begin
addr <= start_addr_tmp ;
en <= 1'b1 ;
we <= 4'hf ;
state <= WRITE_RAM ;
end
WRITE_RAM : begin
if ((addr - start_addr_tmp) == len_tmp - 4)
begin
state <= WRITE_END ;
dout <= 32'd0 ;
en <= 1'b0 ;
we <= 4'd0 ;
end
else
begin
addr <= addr + 32'd4 ;
dout <= dout + 32'd1 ;
end
end
WRITE_END : begin
addr <= 32'd0 ;
write_end <= 1'b1 ;
state <= IDLE ;
end
default : state <= IDLE ;
endcase
end
end
endmodule
4，AXI GPIO模块配置
三，SDK 裸机开发
1，程序设计流程为：
->输入起始地址和长度
->CPU 通过 BRAM 控制器写入 BRAM 数据
->通知 PL控制器读取 BRAM 数据
->PL 内部读完后向相同位置写入数据，初始数据由 CPU 告知
->写完后使能 write_end 信号，触发 GPIO 中断
->中断读取 BRAM 数据，打印显示
2，进入 SDK 后，在 SDK 下新建项目，已经准备好程序。程序也比较简单，首先是进行 GPIO的初始化，中断设置
int Status;
Gpio_flag = 1 ;
Status = XGpio_Initialize(&PL_Gpio, GPIO_DEVICE_ID) ;
if (Status != XST_SUCCESS)
return XST_FAILURE ;
Status = IntrInitFuntion(GPIO_DEVICE_ID, &PL_Gpio) ;
if (Status != XST_SUCCESS)
return XST_FAILURE ;
3,while 语句中需要输入起始地址和长度，之后调用 bram_write 函数
while(1)
{
if (Gpio_flag)
{
Gpio_flag = 0 ;
printf("Please provide start address\t\n") ;
scanf("%d", &Start_Addr) ;
printf("Start address is %d\t\n", Start_Addr) ;
printf("Please provide length\t\n") ;
scanf("%d", &Len) ;
printf("Length is %d\t\n", Len) ;
Status = bram_read_write() ;
if (Status != XST_SUCCESS)
{
xil_printf("Bram Test Failed!\r\n") ;
Gpio_flag = 1 ;
}
}
}
4,中断服务程序中，BRAM 控制器读取 BRAM 的数据，并打印
5,bram_read_write();函数里先通过 BRAM 控制器写入数据，数据初值为 TEST_START_VAL，之后配置 PL RAM 控制器参数，有长度，起始地址，初始数据，以及开始信号。并在函数中判断测试长度是否超出 BRAM 控制器地址范围，如果超出，会报错，需要重新输入地址和长度。
int bram_read_write()
{
u32 Write_Data = TEST_START_VAL ;
int i ;
if ((Start_Addr + Len) > (BRAM_CTRL_HIGH - BRAM_CTRL_BASE + 1)/4)
{
xil_printf("********if exceed BRAM address range, assert error********\r\n");
xil_printf("Error! Exceed Bram Control Address Range!\r\n");
return XST_FAILURE ;
}
for(i = BRAM_BYTENUM*Start_Addr ; i < BRAM_BYTENUM*(Start_Addr + Len) ; i += BRAM_BYTENUM)
{
XBram_WriteReg(XPAR_BRAM_0_BASEADDR, i , Write_Data) ;//Write data to BRAM
Write_Data += 1 ;
}
PL_RAM_CTRL_mWriteReg(PL_RAM_BASE, PL_RAM_LEN , BRAM_BYTENUM*Len) ;//Set ram read and write length
PL_RAM_CTRL_mWriteReg(PL_RAM_BASE, PL_RAM_ST_ADDR , BRAM_BYTENUM*Start_Addr) ;//Set ram start address
PL_RAM_CTRL_mWriteReg(PL_RAM_BASE, PL_RAM_INIT_DATA , (Start_Addr+1)) ;//Set pl initial data
PL_RAM_CTRL_mWriteReg(PL_RAM_BASE, PL_RAM_START , 1) ;//Set ram start signal
return XST_SUCCESS ;
}
6,打开串口软件，下载程序，打印出信息，需要输入起始地址，由于 BRAM 询址为 1K，那么可以设置为 0~1023，长度设置为 1~1024，注意起始地址+长度不要超过 1024，因为超出了询址空间。
四，petalinux使用
1，生成启动文件
source /opt/Xilinx/Vivado/2017.4/settings64.sh
source /opt/pkg/petalinux/settings.sh
petalinux-config --get-hw-description ../linux_base.sdk
petalinux-config -c kernel
petalinux-config -c rootfs
petalinux-build
petalinux-package --boot --fsbl ./images/linux/zynq_fsbl.elf --fpga --u-boot --force
将硬件资源导入petlainux中，生成BOOT.BIN 和image.ub将生成的BOOT.BIN和内核放到板子上，启动系统。
2，BRAM读写编程
#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define BRAM_CTRL_0 0x40000000
#define BRAM_CTRL_1 0x43C00000
#define DATA_LEN 10
int main(int argc, char **argv)
{
unsigned int *map_base0;
unsigned int *map_base1;
int fd = open("/dev/mem", O_RDWR | O_SYNC);
if (fd < 0) {
printf("can not open /dev/mem \n");
return (-1);
}
printf("/dev/mem is open \n");
map_base0 = mmap(NULL, DATA_LEN * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, BRAM_CTRL_0);
map_base1 = mmap(NULL, DATA_LEN * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, BRAM_CTRL_1);
if (map_base0 == 0 || map_base1 == 0 )
{
printf("NULL pointer\n");
}
else
{
printf("mmap successful\n");
}
unsigned long addr;
unsigned int content;
int i = 0;
printf("\nwrite data to bram\n");
for (i = 0; i < DATA_LEN; i++)
{
addr = (unsigned long)(map_base0 + i);
content = i + 2;
map_base0[i] = content;
printf("%2dth data, address: 0x%lx data_write: 0x%x\t\t\n", i, addr, content);
}
printf("\nread data from bram\n");
for (i = 0; i< DATA_LEN; i++)
{
addr = (unsigned long)(map_base1 + i);
content = map_base1[i];
printf("%2dth data, address: 0x%lx data_read: 0x%x\t\t\n", i, addr, content);
}
close(fd);
munmap(map_base0, DATA_LEN);
munmap(map_base1, DATA_LEN);
return 0;
}
3，测试
4，将BRAM与socket进行联合使用，将电脑的数据发到PS端，PS端放在PL端，PL端再发给PS端，PS端发回电脑。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <fcntl.h>
#define PORT 3333
#define BRAM_CTRL0 0x40000000
#define BRAM_CTRL1 0x43C00000
#define DATA_LEN 100
unsigned int *map_base0;
unsigned int *map_base1;
void udp_server(int sockfd)
{
socklen_t len;
struct sockaddr_in server_addr;
int n;
int opt = 1;
len = sizeof(server_addr);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(PORT);
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
printf("can not bind\n");
exit(1);
}
while (1) {
printf("\n========wait for client's request========\n");
n = recvfrom(sockfd, map_base0, 1024, 0, (struct sockaddr *)&server_addr, &len);
char buf[1024];
memcpy(buf, map_base0, 1024);
printf("\nreceive client's data: %s\n", buf);
sendto(sockfd, map_base0, n, 0, (struct sockaddr *)&server_addr, len);
memcpy(buf, map_base1, 1024);
printf("\nsend data to client: %s\n", buf);
}
close(sockfd);
}
int main(int argc, char **argv)
{
int sockfd, devfd;
if ((sockfd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
printf("create socket false\n");
exit(1);
}
if ((devfd = open("/dev/mem", O_RDWR | O_SYNC)) < 0) {
printf("can not open /dev/mem \n");
return (-1);
}
printf("\nopen /dev/mem successful\n");
map_base0 = mmap(NULL, DATA_LEN * 4, PROT_READ | PROT_WRITE, MAP_SHARED, devfd, BRAM_CTRL0);
map_base1 = mmap(NULL, DATA_LEN * 4, PROT_READ | PROT_WRITE, MAP_SHARED, devfd, BRAM_CTRL1);
if (map_base0 ==0 || map_base1 == 0) {
printf("NULL pointer \n");
}
else {
printf("mmap successful\n");
}
udp_server(sockfd);
exit(0);
}