1 from nmigen
.compat
.sim
import run_simulation
2 from nmigen
.cli
import verilog
, rtlil
3 from nmigen
import Module
, Signal
, Mux
, Cat
, Elaboratable
5 from nmutil
.latch
import SRLatch
, latchregister
7 """ LOAD / STORE Computation Unit. Also capable of doing ADD and ADD immediate
9 This module runs a "revolving door" set of four latches, based on
13 * Go_Write *OR* Go_Store
15 (Note that opc_l has been inverted (and qn used), due to SRLatch
16 default reset state being "0" rather than "1")
19 # internal opcodes. hypothetically this could do more combinations.
21 # * bit 0: 0 = ADD , 1 = SUB
22 # * bit 1: 0 = src1, 1 = IMM
25 LDST_OP_ADDI
= 0b0000 # plain ADD (src1 + src2)
26 LDST_OP_SUBI
= 0b0001 # plain SUB (src1 - src2)
27 LDST_OP_ADD
= 0b0010 # immed ADD (imm + src1)
28 LDST_OP_SUB
= 0b0011 # immed SUB (imm - src1)
29 LDST_OP_ST
= 0b0110 # immed ADD plus LD op. ADD result is address
30 LDST_OP_LD
= 0b1010 # immed ADD plus ST op. ADD result is address
33 class LDSTCompUnit(Elaboratable
):
34 """ LOAD / STORE / ADD / SUB Computation Unit
39 * :rwid: register width
41 * :mem: a Memory Module (read-write capable)
46 * :issue_i: LD/ST is being "issued".
47 * :isalu_i: ADD/SUB is being "issued" (aka issue_alu_i)
48 * :shadown_i: Inverted-shadow is being held (stops STORE *and* WRITE)
49 * :go_rd_i: read is being actioned (latches in src regs)
50 * :go_ad_i: address is being actioned (triggers actual mem LD)
51 * :go_st_i: store is being actioned (triggers actual mem STORE)
52 * :go_die_i: resets the unit back to "wait for issue"
54 def __init__(self
, rwid
, opwid
, alu
, mem
):
60 self
.counter
= Signal(4)
61 self
.go_rd_i
= Signal(reset_less
=True) # go read in
62 self
.go_ad_i
= Signal(reset_less
=True) # go address in
63 self
.go_wr_i
= Signal(reset_less
=True) # go write in
64 self
.go_st_i
= Signal(reset_less
=True) # go store in
65 self
.issue_i
= Signal(reset_less
=True) # fn issue in
66 self
.isalu_i
= Signal(reset_less
=True) # fn issue as ALU in
67 self
.shadown_i
= Signal(reset
=1) # shadow function, defaults to ON
68 self
.go_die_i
= Signal() # go die (reset)
70 self
.oper_i
= Signal(opwid
, reset_less
=True) # opcode in
71 self
.imm_i
= Signal(rwid
, reset_less
=True) # immediate in
72 self
.src1_i
= Signal(rwid
, reset_less
=True) # oper1 in
73 self
.src2_i
= Signal(rwid
, reset_less
=True) # oper2 in
75 self
.busy_o
= Signal(reset_less
=True) # fn busy out
76 self
.rd_rel_o
= Signal(reset_less
=True) # request src1/src2
77 self
.adr_rel_o
= Signal(reset_less
=True) # request address (from mem)
78 self
.sto_rel_o
= Signal(reset_less
=True) # request store (to mem)
79 self
.req_rel_o
= Signal(reset_less
=True) # request write (result)
80 self
.data_o
= Signal(rwid
, reset_less
=True) # Dest out (LD or ALU)
81 self
.load_mem_o
= Signal(reset_less
=True) # activate memory LOAD
82 self
.stwd_mem_o
= Signal(reset_less
=True) # activate memory STORE
84 def elaborate(self
, platform
):
89 m
.submodules
.alu
= self
.alu
90 m
.submodules
.src_l
= src_l
= SRLatch(sync
=False)
91 m
.submodules
.opc_l
= opc_l
= SRLatch(sync
=False)
92 m
.submodules
.adr_l
= adr_l
= SRLatch(sync
=False)
93 m
.submodules
.req_l
= req_l
= SRLatch(sync
=False)
94 m
.submodules
.sto_l
= sto_l
= SRLatch(sync
=False)
97 reset_b
= Signal(reset_less
=True)
98 reset_w
= Signal(reset_less
=True)
99 reset_a
= Signal(reset_less
=True)
100 reset_s
= Signal(reset_less
=True)
101 reset_r
= Signal(reset_less
=True)
102 comb
+= reset_b
.eq(self
.go_st_i | self
.go_wr_i | self
.go_die_i
)
103 comb
+= reset_w
.eq(self
.go_wr_i | self
.go_die_i
)
104 comb
+= reset_s
.eq(self
.go_st_i | self
.go_die_i
)
105 comb
+= reset_r
.eq(self
.go_rd_i | self
.go_die_i
)
106 # this one is slightly different, issue_alu_i selects go_wr_i)
107 a_sel
= Mux(self
.isalu_i
, self
.go_wr_i
, self
.go_ad_i
)
108 comb
+= reset_a
.eq(a_sel| self
.go_die_i
)
111 op_alu
= Signal(reset_less
=True)
112 op_is_ld
= Signal(reset_less
=True)
113 op_is_st
= Signal(reset_less
=True)
114 op_ldst
= Signal(reset_less
=True)
115 op_is_imm
= Signal(reset_less
=True)
117 # select immediate or src2 reg to add
118 src2_or_imm
= Signal(self
.rwid
, reset_less
=True)
119 src_sel
= Signal(reset_less
=True)
121 # issue can be either issue_i or issue_alu_i (isalu_i)
122 issue_i
= Signal(reset_less
=True)
123 comb
+= issue_i
.eq(self
.issue_i | self
.isalu_i
)
125 # Ripple-down the latches, each one set cancels the previous.
126 # NOTE: use sync to stop combinatorial loops.
128 # opcode latch - inverted so that busy resets to 0
129 sync
+= opc_l
.s
.eq(issue_i
) # XXX NOTE: INVERTED FROM book!
130 sync
+= opc_l
.r
.eq(reset_b
) # XXX NOTE: INVERTED FROM book!
133 sync
+= src_l
.s
.eq(issue_i
)
134 sync
+= src_l
.r
.eq(reset_r
)
137 sync
+= adr_l
.s
.eq(self
.go_rd_i
)
138 sync
+= adr_l
.r
.eq(reset_a
)
141 sync
+= req_l
.s
.eq(self
.go_ad_i
)
142 sync
+= req_l
.r
.eq(reset_w
)
145 sync
+= sto_l
.s
.eq(self
.go_ad_i
)
146 sync
+= sto_l
.r
.eq(reset_s
)
148 # outputs: busy and release signals
150 comb
+= self
.busy_o
.eq(opc_l
.q
) # busy out
151 comb
+= self
.rd_rel_o
.eq(src_l
.q
& busy_o
) # src1/src2 req rel
152 comb
+= self
.sto_rel_o
.eq(sto_l
.q
& busy_o
& self
.shadown_i
)
154 # request release enabled based on if op is a LD/ST or a plain ALU
155 # if op is an ADD/SUB or a LD, req_rel activates.
156 wr_q
= Signal(reset_less
=True)
157 comb
+= wr_q
.eq(req_l
.q
& (~op_ldst | op_is_ld
))
159 alulatch
= Signal(reset_less
=True)
160 comb
+= alulatch
.eq((op_ldst
& self
.adr_rel_o
) | \
161 (~op_ldst
& self
.req_rel_o
))
163 # only proceed if ALU says its output is valid
164 with m
.If(self
.alu
.n_valid_o
):
166 # write req release out. waits until shadow is dropped.
167 comb
+= self
.req_rel_o
.eq(wr_q
& busy_o
& self
.shadown_i
)
168 # address release only happens on LD/ST, and is shadowed.
169 comb
+= self
.adr_rel_o
.eq(adr_l
.q
& op_ldst
& busy_o
& \
171 # when output latch is ready, and ALU says ready, accept ALU output
172 with m
.If(self
.req_rel_o
):
173 m
.d
.comb
+= self
.alu
.n_ready_i
.eq(1) # tells ALU "thanks got it"
175 # select immediate if opcode says so. however also change the latch
176 # to trigger *from* the opcode latch instead.
177 comb
+= src_sel
.eq(Mux(op_is_imm
, opc_l
.qn
, src_l
.q
))
178 comb
+= src2_or_imm
.eq(Mux(op_is_imm
, self
.imm_i
, self
.src2_i
))
180 # create a latch/register for src1/src2 (include immediate select)
181 latchregister(m
, self
.src1_i
, self
.alu
.a
, src_l
.q
)
182 latchregister(m
, src2_or_imm
, self
.alu
.b
, src_sel
)
184 # create a latch/register for the operand
185 oper_r
= Signal(self
.opwid
, reset_less
=True) # Dest register
186 latchregister(m
, self
.oper_i
, oper_r
, self
.issue_i
)
187 alu_op
= Cat(op_alu
, 0, op_is_imm
) # using alu_hier, here.
188 comb
+= self
.alu
.op
.eq(alu_op
)
190 # and one for the output from the ALU
191 data_r
= Signal(self
.rwid
, reset_less
=True) # Dest register
192 latchregister(m
, self
.alu
.o
, data_r
, alulatch
)
194 # decode bits of operand (latched)
195 comb
+= op_alu
.eq(oper_r
[0])
196 comb
+= op_is_imm
.eq(oper_r
[1])
197 comb
+= op_is_ld
.eq(oper_r
[2])
198 comb
+= op_is_st
.eq(oper_r
[3])
199 comb
+= op_ldst
.eq(op_is_ld | op_is_st
)
200 comb
+= self
.load_mem_o
.eq(op_is_ld
& self
.go_ad_i
)
201 comb
+= self
.stwd_mem_o
.eq(op_is_st
& self
.go_st_i
)
203 # on a go_read, tell the ALU we're accepting data.
204 # NOTE: this spells TROUBLE if the ALU isn't ready!
205 # go_read is only valid for one clock!
206 with m
.If(self
.go_rd_i
): # src operands ready, GO!
207 with m
.If(~self
.alu
.p_ready_o
): # no ACK yet
208 m
.d
.comb
+= self
.alu
.p_valid_i
.eq(1) # so indicate valid
210 # put the register directly onto the output
211 comb
+= self
.data_o
.eq(data_r
)
234 yield self
.load_mem_o
235 yield self
.stwd_mem_o
241 def scoreboard_sim(dut
):
242 yield dut
.dest_i
.eq(1)
243 yield dut
.issue_i
.eq(1)
245 yield dut
.issue_i
.eq(0)
247 yield dut
.src1_i
.eq(1)
248 yield dut
.issue_i
.eq(1)
252 yield dut
.issue_i
.eq(0)
254 yield dut
.go_read_i
.eq(1)
256 yield dut
.go_read_i
.eq(0)
258 yield dut
.go_write_i
.eq(1)
260 yield dut
.go_write_i
.eq(0)
264 def test_scoreboard():
265 from alu_hier
import ALU
268 dut
= LDSTCompUnit(16, 4, alu
, mem
)
269 vl
= rtlil
.convert(dut
, ports
=dut
.ports())
270 with
open("test_ldst_comp.il", "w") as f
:
273 run_simulation(dut
, scoreboard_sim(dut
), vcd_name
='test_ldst_comp.vcd')
275 if __name__
== '__main__':