185 lines
7.2 KiB
Verilog
185 lines
7.2 KiB
Verilog
`timescale 1ns/1ps
|
|
// Continuous byte sampler and write-only DMA for the reserved 8 MiB DDR ring.
|
|
module zynq_la_stream #(
|
|
parameter [31:0] DDR_BASE = 32'h3e000000
|
|
) (
|
|
(* X_INTERFACE_INFO = "xilinx.com:signal:clock:1.0 clk CLK" *)
|
|
(* X_INTERFACE_PARAMETER = "ASSOCIATED_BUSIF s_axi:m_axi, ASSOCIATED_RESET aresetn" *)
|
|
input wire clk,
|
|
(* X_INTERFACE_PARAMETER = "POLARITY ACTIVE_LOW" *)
|
|
input wire aresetn,
|
|
input wire [7:0] digital_inputs,
|
|
(* X_INTERFACE_PARAMETER = "PROTOCOL AXI4LITE, ADDR_WIDTH 12, DATA_WIDTH 32" *)
|
|
input wire [11:0] s_axi_awaddr,
|
|
input wire s_axi_awvalid,
|
|
output wire s_axi_awready,
|
|
input wire [31:0] s_axi_wdata,
|
|
input wire [3:0] s_axi_wstrb,
|
|
input wire s_axi_wvalid,
|
|
output wire s_axi_wready,
|
|
output reg [1:0] s_axi_bresp,
|
|
output reg s_axi_bvalid,
|
|
input wire s_axi_bready,
|
|
input wire [11:0] s_axi_araddr,
|
|
input wire s_axi_arvalid,
|
|
output wire s_axi_arready,
|
|
output reg [31:0] s_axi_rdata,
|
|
output wire [1:0] s_axi_rresp,
|
|
output reg s_axi_rvalid,
|
|
input wire s_axi_rready,
|
|
(* X_INTERFACE_PARAMETER = "PROTOCOL AXI4, READ_WRITE_MODE WRITE_ONLY, ADDR_WIDTH 32, DATA_WIDTH 64, MAX_BURST_LENGTH 16, NUM_WRITE_OUTSTANDING 1" *)
|
|
output wire [31:0] m_axi_awaddr,
|
|
output wire [7:0] m_axi_awlen,
|
|
output wire [2:0] m_axi_awsize,
|
|
output wire [1:0] m_axi_awburst,
|
|
output wire [3:0] m_axi_awcache,
|
|
output wire [2:0] m_axi_awprot,
|
|
output wire m_axi_awvalid,
|
|
input wire m_axi_awready,
|
|
output wire [63:0] m_axi_wdata,
|
|
output wire [7:0] m_axi_wstrb,
|
|
output wire m_axi_wlast,
|
|
output wire m_axi_wvalid,
|
|
input wire m_axi_wready,
|
|
input wire [1:0] m_axi_bresp,
|
|
input wire m_axi_bvalid,
|
|
output wire m_axi_bready
|
|
);
|
|
localparam [1:0] IDLE=0, ADDR=1, DATA=2, RESP=3;
|
|
localparam [31:0] MAGIC=32'h31534c5a;
|
|
(* ASYNC_REG = "TRUE" *) reg [7:0] input_meta, input_sync;
|
|
reg [1:0] state;
|
|
reg running;
|
|
reg [1:0] fault; // 1: FIFO or ring overflow. 2: DDR AXI response error.
|
|
reg [15:0] divider, ticks;
|
|
reg [2:0] byte_index;
|
|
reg [63:0] assembly;
|
|
reg [7:0] wr_pos, rd_pos;
|
|
reg [8:0] used;
|
|
(* ram_style = "distributed" *) reg [63:0] fifo [0:255];
|
|
reg [3:0] beat;
|
|
reg [6:0] burst_index;
|
|
reg [31:0] produced, consumed;
|
|
wire ring_full = produced-consumed == 32'd512;
|
|
wire sample_now = running && ticks==0;
|
|
wire pop = m_axi_wvalid && m_axi_wready;
|
|
wire word_now = sample_now && byte_index==7;
|
|
wire push = word_now && (used!=256 || pop);
|
|
wire [63:0] next_word = {input_sync, assembly[63:8]};
|
|
|
|
reg aw_pending, w_pending;
|
|
reg [11:0] aw_addr;
|
|
reg [31:0] w_data;
|
|
reg [3:0] w_strb;
|
|
wire commit = aw_pending && w_pending && !s_axi_bvalid;
|
|
wire start = commit && w_strb==4'hf && aw_addr==12'h014 &&
|
|
w_data==1 && !running && state==IDLE;
|
|
wire stop = commit && w_strb==4'hf && aw_addr==12'h014 && w_data==2;
|
|
|
|
assign s_axi_awready = aresetn && !aw_pending && !s_axi_bvalid;
|
|
assign s_axi_wready = aresetn && !w_pending && !s_axi_bvalid;
|
|
assign s_axi_arready = aresetn && !s_axi_rvalid;
|
|
assign s_axi_rresp = 2'b00;
|
|
|
|
assign m_axi_awaddr = {DDR_BASE[31:23], produced[8:0], burst_index, 7'b0};
|
|
assign m_axi_awlen = 8'd15;
|
|
assign m_axi_awsize = 3'd3;
|
|
assign m_axi_awburst = 2'b01;
|
|
assign m_axi_awcache = 4'b0010; // Normal noncacheable, nonbufferable.
|
|
assign m_axi_awprot = 3'b000;
|
|
assign m_axi_awvalid = state==ADDR;
|
|
assign m_axi_wdata = fifo[rd_pos];
|
|
assign m_axi_wstrb = 8'hff;
|
|
assign m_axi_wlast = beat==15;
|
|
assign m_axi_wvalid = state==DATA;
|
|
assign m_axi_bready = state==RESP;
|
|
|
|
always @(posedge clk) begin
|
|
input_meta <= digital_inputs;
|
|
input_sync <= input_meta;
|
|
if (!aresetn) begin
|
|
aw_pending<=0; w_pending<=0;
|
|
s_axi_bvalid<=0; s_axi_bresp<=0; s_axi_rvalid<=0; s_axi_rdata<=0;
|
|
divider<=10; consumed<=0;
|
|
end else begin
|
|
if (s_axi_awvalid && s_axi_awready) begin aw_addr<=s_axi_awaddr; aw_pending<=1; end
|
|
if (s_axi_wvalid && s_axi_wready) begin
|
|
w_data<=s_axi_wdata; w_strb<=s_axi_wstrb; w_pending<=1;
|
|
end
|
|
if (s_axi_bvalid && s_axi_bready) s_axi_bvalid<=0;
|
|
if (commit) begin
|
|
aw_pending<=0; w_pending<=0; s_axi_bvalid<=1; s_axi_bresp<=2'b10;
|
|
if (w_strb==4'hf) case (aw_addr)
|
|
12'h010: if (!running && state==IDLE && w_data>=10 && w_data<=65535) begin
|
|
divider<=w_data[15:0]; s_axi_bresp<=0;
|
|
end
|
|
12'h014: if (start || stop) s_axi_bresp<=0;
|
|
12'h01c: if (w_data==consumed+1 && consumed!=produced) begin
|
|
consumed<=w_data; s_axi_bresp<=0;
|
|
end
|
|
default: ;
|
|
endcase
|
|
end
|
|
if (start) consumed<=0;
|
|
if (s_axi_rvalid && s_axi_rready) s_axi_rvalid<=0;
|
|
if (s_axi_arvalid && s_axi_arready) begin
|
|
s_axi_rvalid<=1;
|
|
case (s_axi_araddr)
|
|
12'h000: s_axi_rdata<=MAGIC;
|
|
12'h004: s_axi_rdata<={28'b0, fault, (state!=IDLE), running};
|
|
12'h008: s_axi_rdata<=100000000;
|
|
12'h00c: s_axi_rdata<=16384;
|
|
12'h010: s_axi_rdata<={16'b0,divider};
|
|
12'h018: s_axi_rdata<=produced;
|
|
12'h01c: s_axi_rdata<=consumed;
|
|
default: s_axi_rdata<=0;
|
|
endcase
|
|
end
|
|
end
|
|
end
|
|
|
|
always @(posedge clk) begin
|
|
if (push && aresetn) fifo[wr_pos] <= next_word;
|
|
if (!aresetn || start) begin
|
|
state<=IDLE; running<=aresetn; fault<=0;
|
|
ticks<=0; byte_index<=0; assembly<=0;
|
|
wr_pos<=0; rd_pos<=0; used<=0;
|
|
beat<=0; burst_index<=0; produced<=0;
|
|
end else begin
|
|
if (stop) running<=0;
|
|
if (running) begin
|
|
if (sample_now) begin
|
|
ticks<=divider-1'b1;
|
|
assembly<=next_word;
|
|
byte_index<=byte_index+1'b1;
|
|
end else ticks<=ticks-1'b1;
|
|
if (word_now && !push) begin running<=0; fault<=1; end
|
|
end
|
|
if (push) wr_pos<=wr_pos+1'b1;
|
|
if (pop) rd_pos<=rd_pos+1'b1;
|
|
case ({push,pop})
|
|
2'b10: used<=used+1'b1;
|
|
2'b01: used<=used-1'b1;
|
|
default: ;
|
|
endcase
|
|
case (state)
|
|
IDLE: if (running && !stop && !ring_full && used>=16) state<=ADDR;
|
|
ADDR: if (m_axi_awready) begin state<=DATA; beat<=0; end
|
|
DATA: if (pop) begin
|
|
beat<=beat+1'b1;
|
|
if (m_axi_wlast) state<=RESP;
|
|
end
|
|
RESP: if (m_axi_bvalid) begin
|
|
state<=IDLE;
|
|
if (m_axi_bresp!=0) begin running<=0; fault<=2; end
|
|
else begin
|
|
burst_index<=burst_index+1'b1;
|
|
if (burst_index==127) produced<=produced+1'b1;
|
|
end
|
|
end
|
|
default: state<=IDLE;
|
|
endcase
|
|
end
|
|
end
|
|
endmodule
|