Add chip enable correctness for CellularRAM.
[firearm.git] / Issue.v
... / ...
CommitLineData
1`include "ARM_Constants.v"
2
3module Issue(
4 input clk,
5 input Nrst, /* XXX not used yet */
6
7 input stall_1a, /* pipeline control */
8 input flush_1a,
9
10 input bubble_1a, /* stage inputs */
11 input [31:0] insn_1a,
12 input [31:0] pc_1a,
13 input [31:0] cpsr_1a,
14
15 output wire stall_0a, /* stage outputs */
16 output reg bubble_2a = 1,
17 output reg [31:0] pc_2a = 0,
18 output reg [31:0] insn_2a = 0
19 /* XXX other? */
20 );
21
22`ifdef COPY_PASTA_FODDER
23 /* from page 2 of ARM7TDMIvE2.pdf */
24 casex (insn_1a)
25 `DECODE_ALU_MULT: /* Multiply -- must come before ALU, because it pattern matches a specific case of ALU */
26// `DECODE_ALU_MUL_LONG: /* Multiply long */
27 `DECODE_ALU_MRS: /* MRS (Transfer PSR to register) */
28 `DECODE_ALU_MSR: /* MSR (Transfer register to PSR) */
29 `DECODE_ALU_MSR_FLAGS: /* MSR (Transfer register or immediate to PSR, flag bits only) */
30 `DECODE_ALU_SWP: /* Atomic swap */
31 `DECODE_ALU_BX: /* Branch */
32 `DECODE_ALU_HDATA_REG: /* Halfword transfer - register offset */
33 `DECODE_ALU_HDATA_IMM: /* Halfword transfer - immediate offset */
34 `DECODE_ALU: /* ALU */
35 `DECODE_LDRSTR_UNDEFINED: /* Undefined. I hate ARM */
36 `DECODE_LDRSTR: /* Single data transfer */
37 `DECODE_LDMSTM: /* Block data transfer */
38 `DECODE_BRANCH: /* Branch */
39 `DECODE_LDCSTC: /* Coprocessor data transfer */
40 `DECODE_CDP: /* Coprocessor data op */
41 `DECODE_MRCMCR: /* Coprocessor register transfer */
42 `DECODE_SWI: /* SWI */
43 default: /* X everything else out */
44 endcase
45`endif
46
47 /* Flag setting */
48 reg use_cpsr;
49 reg [15:0] use_regs;
50 reg def_cpsr;
51 reg [15:0] def_regs;
52
53 function [15:0] idxbit;
54 input [3:0] r;
55 if (r == 15)
56 idxbit = 0;
57 else
58 idxbit = (16'b1) << r;
59 endfunction
60
61 wire [3:0] rn = insn_1a[19:16];
62 wire [3:0] rd = insn_1a[15:12];
63 wire [3:0] rs = insn_1a[11:8];
64 wire [3:0] rm = insn_1a[3:0];
65 wire [3:0] cond = insn_1a[31:28];
66
67 wire [3:0] rd_mul = insn_1a[19:16];
68 wire [3:0] rn_mul = insn_1a[15:12];
69 wire [3:0] rs_mul = insn_1a[11:8];
70
71 wire [3:0] alu_opc = insn_1a[24:21];
72
73 function alu_is_logical;
74 input [3:0] op;
75
76 case (op)
77 `ALU_AND,`ALU_EOR,`ALU_TST,`ALU_TEQ,`ALU_ORR,`ALU_MOV,`ALU_BIC,`ALU_MVN: alu_is_logical = 1;
78 default: alu_is_logical = 0;
79 endcase
80 endfunction
81
82 function alu_flags_only;
83 input [3:0] op;
84
85 case (op)
86 `ALU_TST,`ALU_TEQ,`ALU_CMP,`ALU_CMN: alu_flags_only = 1;
87 default: alu_flags_only = 0;
88 endcase
89 endfunction
90
91 function shift_requires_carry;
92 input [7:0] shift;
93
94 case(shift[1:0])
95 `SHIFT_LSL: shift_requires_carry = (shift[7:2] == 0);
96 `SHIFT_LSR: shift_requires_carry = 0;
97 `SHIFT_ASR: shift_requires_carry = 0;
98 `SHIFT_ROR: shift_requires_carry = (shift[7:2] == 0);
99 endcase
100 endfunction
101
102 always @(*)
103 casez (insn_1a)
104 `DECODE_ALU_MULT: /* Multiply -- must come before ALU, because it pattern matches a specific case of ALU */
105 begin
106 use_cpsr = `COND_MATTERS(cond);
107 use_regs = (insn_1a[21] /* accum */ ? idxbit(rn_mul) : 0) | idxbit(rs_mul) | idxbit(rm);
108 def_cpsr = insn_1a[20] /* setcc */;
109 def_regs = idxbit(rd_mul);
110 end
111// `DECODE_ALU_MUL_LONG: /* Multiply long */
112 `DECODE_ALU_MRS: /* MRS (Transfer PSR to register) */
113 begin
114 use_cpsr = `COND_MATTERS(cond) || (insn_1a[22] == 0) /* Source = CPSR */;
115 use_regs = 0;
116 def_cpsr = 0;
117 def_regs = idxbit(rd);
118 end
119 `DECODE_ALU_MSR: /* MSR (Transfer register to PSR) */
120 begin
121 use_cpsr = `COND_MATTERS(cond);
122 use_regs = idxbit(rm);
123 def_cpsr = 1;
124 def_regs = 0;
125 end
126 `DECODE_ALU_MSR_FLAGS: /* MSR (Transfer register or immediate to PSR, flag bits only) */
127 begin
128 use_cpsr = `COND_MATTERS(cond);
129 use_regs = insn_1a[25] ? 0 : idxbit(rm);
130 def_cpsr = 1;
131 def_regs = 0;
132 end
133 `DECODE_ALU_SWP: /* Atomic swap */
134 begin
135 use_cpsr = `COND_MATTERS(cond);
136 use_regs = idxbit(rn) | idxbit(rm);
137 def_cpsr = 0;
138 def_regs = idxbit(rd);
139 end
140 `DECODE_ALU_BX: /* Branch */
141 begin
142 use_cpsr = `COND_MATTERS(cond);
143 use_regs = idxbit(rm);
144 def_cpsr = 0; // don't care, we'll never get there
145 def_regs = 0;
146 end
147 `DECODE_ALU_HDATA_REG: /* Halfword transfer - register offset */
148 begin
149 use_cpsr = `COND_MATTERS(cond);
150 use_regs = idxbit(rn) | idxbit(rm) | (insn_1a[20] /* L */ ? 0 : idxbit(rd));
151 def_cpsr = 0;
152 def_regs = insn_1a[20] /* L */ ? idxbit(rd) : 0;
153 end
154 `DECODE_ALU_HDATA_IMM: /* Halfword transfer - immediate offset */
155 begin
156 use_cpsr = `COND_MATTERS(cond);
157 use_regs = idxbit(rn) | (insn_1a[20] /* L */ ? 0 : idxbit(rd));
158 def_cpsr = 0;
159 def_regs = insn_1a[20] /* L */ ? idxbit(rd) : 0;
160 end
161 `DECODE_ALU: /* ALU */
162 begin
163 use_cpsr = `COND_MATTERS(cond) | (!insn_1a[25] /* I */ && shift_requires_carry(insn_1a[11:4]));
164 use_regs =
165 (insn_1a[25] /* I */ ? 0 :
166 (insn_1a[4] /* shift by reg */ ?
167 (idxbit(rs) | idxbit(rm)) :
168 (idxbit(rm)))) |
169 (((alu_opc != `ALU_MOV) && (alu_opc != `ALU_MVN)) ? idxbit(rn) : 0);
170 def_cpsr = insn_1a[20] /* S */;
171 def_regs = alu_flags_only(alu_opc) ? 0 : idxbit(rd);
172 end
173 `DECODE_LDRSTR_UNDEFINED: /* Undefined. I hate ARM */
174 begin
175 use_cpsr = 0;
176 use_regs = 0;
177 def_cpsr = 0;
178 def_regs = 0;
179 end
180 `DECODE_LDRSTR:
181 begin
182 use_cpsr = `COND_MATTERS(cond);
183 use_regs = idxbit(rn) | (insn_1a[25] /* I */ ? idxbit(rm) : 0) | (insn_1a[20] /* L */ ? 0 : idxbit(rd));
184 def_cpsr = 0;
185 def_regs = insn_1a[20] /* L */ ? idxbit(rd) : 0;
186 end
187 `DECODE_LDMSTM: /* Block data transfer */
188 begin
189 use_cpsr = `COND_MATTERS(cond);
190 use_regs = idxbit(rn) | (insn_1a[20] /* L */ ? 0 : insn_1a[15:0]);
191 def_cpsr = insn_1a[22]; /* This is a superset of all cases, anyway. */
192 def_regs = (insn_1a[21] /* W */ ? idxbit(rn) : 0) | (insn_1a[20] /* L */ ? insn_1a[15:0] : 0);
193 end
194 `DECODE_BRANCH: /* Branch */
195 begin
196 use_cpsr = `COND_MATTERS(cond);
197 use_regs = 0;
198 def_cpsr = 0;
199 def_regs = insn_1a[24] /* L */ ? (16'b1 << 14) : 0;
200 end
201 `DECODE_LDCSTC: /* Coprocessor data transfer */
202 begin
203 use_cpsr = `COND_MATTERS(cond);
204 use_regs = idxbit(rn);
205 def_cpsr = 0;
206 def_regs = insn_1a[21] /* W */ ? idxbit(rn) : 0;
207 end
208 `DECODE_CDP: /* Coprocessor data op */
209 begin
210 use_cpsr = `COND_MATTERS(cond);
211 use_regs = 0;
212 def_cpsr = 0;
213 def_regs = 0;
214 end
215 `DECODE_MRCMCR: /* Coprocessor register transfer */
216 begin
217 use_cpsr = `COND_MATTERS(cond);
218 use_regs = insn_1a[20] /* L */ ? 0 : idxbit(rd);
219 def_cpsr = 0;
220 def_regs = insn_1a[20] /* L */ ? idxbit(rd) : 0;
221 end
222 `DECODE_SWI: /* SWI */
223 begin
224 use_cpsr = `COND_MATTERS(cond);
225 use_regs = 0;
226 def_cpsr = 0;
227 def_regs = 0;
228 end
229 default: /* X everything else out */
230 begin
231 use_cpsr = 1'bx;
232 use_regs = 16'bxxxxxxxxxxxxxxxx;
233 def_cpsr = 1'bx;
234 def_regs = 16'bxxxxxxxxxxxxxxxx;
235 end
236 endcase
237
238 /* Condition checking logic */
239 reg condition_met_1a;
240 always @(*)
241 casez(insn_1a[31:28])
242 `COND_EQ: condition_met_1a = cpsr_1a[`CPSR_Z];
243 `COND_NE: condition_met_1a = !cpsr_1a[`CPSR_Z];
244 `COND_CS: condition_met_1a = cpsr_1a[`CPSR_C];
245 `COND_CC: condition_met_1a = !cpsr_1a[`CPSR_C];
246 `COND_MI: condition_met_1a = cpsr_1a[`CPSR_N];
247 `COND_PL: condition_met_1a = !cpsr_1a[`CPSR_N];
248 `COND_VS: condition_met_1a = cpsr_1a[`CPSR_V];
249 `COND_VC: condition_met_1a = !cpsr_1a[`CPSR_V];
250 `COND_HI: condition_met_1a = cpsr_1a[`CPSR_C] && !cpsr_1a[`CPSR_Z];
251 `COND_LS: condition_met_1a = !cpsr_1a[`CPSR_C] || cpsr_1a[`CPSR_Z];
252 `COND_GE: condition_met_1a = cpsr_1a[`CPSR_N] == cpsr_1a[`CPSR_V];
253 `COND_LT: condition_met_1a = cpsr_1a[`CPSR_N] != cpsr_1a[`CPSR_V];
254 `COND_GT: condition_met_1a = !cpsr_1a[`CPSR_Z] && (cpsr_1a[`CPSR_N] == cpsr_1a[`CPSR_V]);
255 `COND_LE: condition_met_1a = cpsr_1a[`CPSR_Z] || (cpsr_1a[`CPSR_N] != cpsr_1a[`CPSR_V]);
256 `COND_AL: condition_met_1a = 1;
257 `COND_NV: condition_met_1a = 0;
258 default: condition_met_1a = 1'bx;
259 endcase
260
261 /* Issue logic */
262 /* Once it's hit writeback, it's hit the regfile via forwarding so you're done. */
263 reg cpsr_inflight_2a = 0, cpsr_inflight_3a = 0;
264 reg [15:0] regs_inflight_2a = 0, regs_inflight_3a = 0;
265
266 wire waiting_cpsr_1a = use_cpsr & (cpsr_inflight_2a | cpsr_inflight_3a);
267 wire waiting_regs_1a = |(use_regs & (regs_inflight_2a | regs_inflight_3a));
268 wire waiting_1a = waiting_cpsr_1a | waiting_regs_1a;
269 assign stall_0a = (waiting_1a && !bubble_1a && !flush_1a) || stall_1a;
270
271 reg delayedflush_1a = 0;
272 always @(posedge clk/* or negedge Nrst*/)
273 if (!Nrst)
274 delayedflush_1a <= 0;
275 else if (flush_1a && stall_0a /* halp! I can't do it now, maybe later? */)
276 delayedflush_1a <= 1;
277 else if (!stall_0a /* anything has been handled this time around */)
278 delayedflush_1a <= 0;
279
280 /* Actually do the issue. */
281 always @(posedge clk or negedge Nrst)
282 begin
283 if (waiting_1a)
284 $display("ISSUE: Stalling instruction %08x because %d/%d", insn_1a, waiting_cpsr_1a, waiting_regs_1a);
285
286 if (!Nrst) begin
287 bubble_2a <= 1;
288 /*AUTORESET*/
289 // Beginning of autoreset for uninitialized flops
290 cpsr_inflight_2a <= 1'h0;
291 cpsr_inflight_3a <= 1'h0;
292 insn_2a <= 32'h0;
293 pc_2a <= 32'h0;
294 regs_inflight_2a <= 16'h0;
295 regs_inflight_3a <= 16'h0;
296 // End of automatics
297 end else if (!stall_1a)
298 begin
299 cpsr_inflight_3a <= cpsr_inflight_2a; /* I'm not sure how well selects work with arrays, and that seems like a dumb thing to get anusulated by. */
300 cpsr_inflight_2a <= (waiting_1a || bubble_1a || !condition_met_1a) ? 0 : def_cpsr;
301 regs_inflight_3a <= regs_inflight_2a;
302 regs_inflight_2a <= (waiting_1a || bubble_1a || !condition_met_1a) ? 0 : def_regs;
303
304 bubble_2a <= bubble_1a | waiting_1a | !condition_met_1a | flush_1a | delayedflush_1a;
305 pc_2a <= pc_1a;
306 insn_2a <= insn_1a;
307 end
308 end
309endmodule
This page took 0.022487 seconds and 5 git commands to generate.