summaryrefslogtreecommitdiff
path: root/tb/mem_interconnect.sv
blob: e9475681d629e75c097da26bd898a5697537b756 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
module mem_interconnect
(
	input  logic        clk,
	                    rst_n,

	input  logic        avl_waitrequest,
	input  logic[127:0] avl_readdata,
	output logic[31:0]  avl_address,
	output logic        avl_read,
	                    avl_write,
	output logic[127:0] avl_writedata,
	output logic[15:0]  avl_byteenable,

	input  logic[31:0]  mem_0_address,
	                    mem_1_address,
	                    mem_2_address,
	                    mem_3_address,
	input  logic        mem_0_read,
	                    mem_1_read,
	                    mem_2_read,
	                    mem_3_read,
	                    mem_0_write,
	                    mem_1_write,
	                    mem_2_write,
	                    mem_3_write,
	input  logic[127:0] mem_0_writedata,
	                    mem_1_writedata,
	                    mem_2_writedata,
	                    mem_3_writedata,
	input  logic[15:0]  mem_0_byteenable,
	                    mem_1_byteenable,
	                    mem_2_byteenable,
	                    mem_3_byteenable,
	output logic        mem_0_waitrequest,
	                    mem_1_waitrequest,
	                    mem_2_waitrequest,
	                    mem_3_waitrequest,
	output logic[127:0] mem_0_readdata,
	                    mem_1_readdata,
	                    mem_2_readdata,
	                    mem_3_readdata
);

	logic last_hold;
	logic[1:0] last_select, select;

	assign mem_0_readdata = avl_readdata;
	assign mem_1_readdata = avl_readdata;
	assign mem_2_readdata = avl_readdata;
	assign mem_3_readdata = avl_readdata;

	always_comb begin
		// Arbitraje round-robin
		unique case (last_select)
			2'd0:
				if (mem_1_read || mem_1_write)
					select = 2'd1;
				else if (mem_2_read || mem_2_write)
					select = 2'd2;
				else if (mem_3_read || mem_3_write)
					select = 2'd3;
				else
					select = 2'd0;

			2'd1:
				if (mem_2_read || mem_2_write)
					select = 2'd2;
				else if (mem_3_read || mem_3_write)
					select = 2'd3;
				else if (mem_0_read || mem_0_write)
					select = 2'd0;
				else
					select = 2'd1;

			2'd2:
				if (mem_3_read || mem_3_write)
					select = 2'd3;
				else if (mem_0_read || mem_0_write)
					select = 2'd0;
				else if (mem_1_read || mem_1_write)
					select = 2'd1;
				else
					select = 2'd2;

			2'd3:
				if (mem_0_read || mem_0_write)
					select = 2'd0;
				else if (mem_1_read || mem_1_write)
					select = 2'd1;
				else if (mem_2_read || mem_2_write)
					select = 2'd2;
				else
					select = 2'd3;
		endcase

		if (last_hold)
			select = last_select;

		mem_0_waitrequest = 1;
		mem_1_waitrequest = 1;
		mem_2_waitrequest = 1;
		mem_3_waitrequest = 1;

		unique case (select)
			2'd0: begin
				avl_read = mem_0_read;
				avl_write = mem_0_write;
				avl_address = mem_0_address;
				avl_writedata = mem_0_writedata;
				avl_byteenable = mem_0_byteenable;
				mem_0_waitrequest = avl_waitrequest;
			end

			2'd1: begin
				avl_read = mem_1_read;
				avl_write = mem_1_write;
				avl_address = mem_1_address;
				avl_writedata = mem_1_writedata;
				avl_byteenable = mem_1_byteenable;
				mem_1_waitrequest = avl_waitrequest;
			end

			2'd2: begin
				avl_read = mem_2_read;
				avl_write = mem_2_write;
				avl_address = mem_2_address;
				avl_writedata = mem_2_writedata;
				avl_byteenable = mem_2_byteenable;
				mem_2_waitrequest = avl_waitrequest;
			end

			2'd3: begin
				avl_read = mem_3_read;
				avl_write = mem_3_write;
				avl_address = mem_3_address;
				avl_writedata = mem_3_writedata;
				avl_byteenable = mem_3_byteenable;
				mem_3_waitrequest = avl_waitrequest;
			end
		endcase
	end

	always @(posedge clk or negedge rst_n)
		if (!rst_n) begin
			last_hold <= 1;
			last_select <= 2'd0;
		end else begin
			last_hold <= (avl_read || avl_write) && avl_waitrequest;
			last_select <= select;
		end

endmodule