3 This first version is intended for prototyping and test purposes:
4 it has "direct" access to Memory.
6 The intention is that this version remains an integral part of the
7 test infrastructure, and, just as with minerva's memory arrangement,
8 a dynamic runtime config *selects* alternative memory arrangements
9 rather than *replaces and discards* this code.
13 * https://bugs.libre-soc.org/show_bug.cgi?id=216
14 * https://libre-soc.org/3d_gpu/architecture/memory_and_cache/
18 from nmigen
.compat
.sim
import run_simulation
, Settle
19 from nmigen
.cli
import rtlil
20 from nmigen
import Module
, Signal
, Mux
, Elaboratable
, Cat
, Const
21 from nmutil
.iocontrol
import RecordObject
22 from nmigen
.utils
import log2_int
24 from nmutil
.latch
import SRLatch
, latchregister
25 from nmutil
.util
import rising_edge
26 from soc
.decoder
.power_decoder2
import Data
27 from soc
.scoreboard
.addr_match
import LenExpand
29 # for testing purposes
30 from soc
.experiment
.testmem
import TestMemory
35 class PortInterface(RecordObject
):
38 defines the interface - the API - that the LDSTCompUnit connects
39 to. note that this is NOT a "fire-and-forget" interface. the
40 LDSTCompUnit *must* be kept appraised that the request is in
41 progress, and only when it has a 100% successful completion
42 can the notification be given (busy dropped).
44 The interface FSM rules are as follows:
46 * if busy_o is asserted, a LD/ST is in progress. further
47 requests may not be made until busy_o is deasserted.
49 * only one of is_ld_i or is_st_i may be asserted. busy_o
50 will immediately be asserted and remain asserted.
52 * addr.ok is to be asserted when the LD/ST address is known.
53 addr.data is to be valid on the same cycle.
55 addr.ok and addr.data must REMAIN asserted until busy_o
56 is de-asserted. this ensures that there is no need
57 for the L0 Cache/Buffer to have an additional address latch
58 (because the LDSTCompUnit already has it)
60 * addr_ok_o (or addr_exc_o) must be waited for. these will
61 be asserted *only* for one cycle and one cycle only.
63 * addr_exc_o will be asserted if there is no chance that the
64 memory request may be fulfilled.
66 busy_o is deasserted on the same cycle as addr_exc_o is asserted.
68 * conversely: addr_ok_o must *ONLY* be asserted if there is a
69 HUNDRED PERCENT guarantee that the memory request will be
72 * for a LD, ld.ok will be asserted - for only one clock cycle -
73 at any point in the future that is acceptable to the underlying
74 Memory subsystem. the recipient MUST latch ld.data on that cycle.
76 busy_o is deasserted on the same cycle as ld.ok is asserted.
78 * for a ST, st.ok may be asserted only after addr_ok_o had been
79 asserted, alongside valid st.data at the same time. st.ok
80 must only be asserted for one cycle.
82 the underlying Memory is REQUIRED to pick up that data and
83 guarantee its delivery. no back-acknowledgement is required.
85 busy_o is deasserted on the cycle AFTER st.ok is asserted.
88 def __init__(self
, name
=None, regwid
=64, addrwid
=48):
91 self
._addrwid
= addrwid
93 RecordObject
.__init
__(self
, name
=name
)
95 # distinguish op type (ld/st)
96 self
.is_ld_i
= Signal(reset_less
=True)
97 self
.is_st_i
= Signal(reset_less
=True)
99 # LD/ST data length (TODO: other things may be needed)
100 self
.data_len
= Signal(4, reset_less
=True)
103 self
.busy_o
= Signal(reset_less
=True) # do not use if busy
104 self
.go_die_i
= Signal(reset_less
=True) # back to reset
105 self
.addr
= Data(addrwid
, "addr_i") # addr/addr-ok
106 # addr is valid (TLB, L1 etc.)
107 self
.addr_ok_o
= Signal(reset_less
=True)
108 self
.addr_exc_o
= Signal(reset_less
=True) # TODO, "type" of exception
111 self
.ld
= Data(regwid
, "ld_data_o") # ok to be set by L0 Cache/Buf
112 self
.st
= Data(regwid
, "st_data_i") # ok to be set by CompUnit
114 def connect_port(self
, inport
):
115 print("connect_port", self
, inport
)
116 return [self
.is_ld_i
.eq(inport
.is_ld_i
),
117 self
.is_st_i
.eq(inport
.is_st_i
),
118 self
.data_len
.eq(inport
.data_len
),
119 self
.go_die_i
.eq(inport
.go_die_i
),
120 self
.addr
.data
.eq(inport
.addr
.data
),
121 self
.addr
.ok
.eq(inport
.addr
.ok
),
122 self
.st
.eq(inport
.st
),
123 inport
.ld
.eq(self
.ld
),
124 inport
.busy_o
.eq(self
.busy_o
),
125 inport
.addr_ok_o
.eq(self
.addr_ok_o
),
126 inport
.addr_exc_o
.eq(self
.addr_exc_o
),
130 class PortInterfaceBase(Elaboratable
):
133 Base class for PortInterface-compliant Memory read/writers
136 def __init__(self
, regwid
=64, addrwid
=4):
138 self
.addrwid
= addrwid
139 self
.pi
= PortInterface("ldst_port0", regwid
, addrwid
)
143 return log2_int(self
.regwid
//8)
145 def splitaddr(self
, addr
):
146 """split the address into top and bottom bits of the memory granularity
148 return addr
[:self
.addrbits
], addr
[self
.addrbits
:]
150 def connect_port(self
, inport
):
151 return self
.pi
.connect_port(inport
)
153 def set_wr_addr(self
, m
, addr
, mask
): pass
154 def set_rd_addr(self
, m
, addr
, mask
): pass
155 def set_wr_data(self
, m
, data
, wen
): pass
156 def get_rd_data(self
, m
): pass
158 def elaborate(self
, platform
):
160 comb
, sync
= m
.d
.comb
, m
.d
.sync
162 # state-machine latches
163 m
.submodules
.st_active
= st_active
= SRLatch(False, name
="st_active")
164 m
.submodules
.st_done
= st_done
= SRLatch(False, name
="st_done")
165 m
.submodules
.ld_active
= ld_active
= SRLatch(False, name
="ld_active")
166 m
.submodules
.reset_l
= reset_l
= SRLatch(True, name
="reset")
167 m
.submodules
.adrok_l
= adrok_l
= SRLatch(False, name
="addr_acked")
168 m
.submodules
.busy_l
= busy_l
= SRLatch(False, name
="busy")
169 m
.submodules
.cyc_l
= cyc_l
= SRLatch(True, name
="cyc")
173 sync
+= st_done
.s
.eq(0)
174 comb
+= st_done
.r
.eq(0)
175 comb
+= st_active
.r
.eq(0)
176 comb
+= ld_active
.r
.eq(0)
177 comb
+= cyc_l
.s
.eq(0)
178 comb
+= cyc_l
.r
.eq(0)
179 comb
+= busy_l
.s
.eq(0)
180 comb
+= busy_l
.r
.eq(0)
181 sync
+= adrok_l
.s
.eq(0)
182 comb
+= adrok_l
.r
.eq(0)
184 # expand ld/st binary length/addr[:3] into unary bitmap
185 m
.submodules
.lenexp
= lenexp
= LenExpand(4, 8)
187 lds
= Signal(reset_less
=True)
188 sts
= Signal(reset_less
=True)
190 comb
+= lds
.eq(pi
.is_ld_i
) # ld-req signals
191 comb
+= sts
.eq(pi
.is_st_i
) # st-req signals
194 busy_delay
= Signal()
196 sync
+= busy_delay
.eq(pi
.busy_o
)
197 comb
+= busy_edge
.eq(pi
.busy_o
& ~busy_delay
)
199 # activate mode: only on "edge"
200 comb
+= ld_active
.s
.eq(rising_edge(m
, lds
)) # activate LD mode
201 comb
+= st_active
.s
.eq(rising_edge(m
, sts
)) # activate ST mode
203 # LD/ST requested activates "busy" (only if not already busy)
204 with m
.If(self
.pi
.is_ld_i | self
.pi
.is_st_i
):
205 comb
+= busy_l
.s
.eq(~busy_delay
)
207 # if now in "LD" mode: wait for addr_ok, then send the address out
208 # to memory, acknowledge address, and send out LD data
209 with m
.If(ld_active
.q
):
210 # set up LenExpander with the LD len and lower bits of addr
211 lsbaddr
, msbaddr
= self
.splitaddr(pi
.addr
.data
)
212 comb
+= lenexp
.len_i
.eq(pi
.data_len
)
213 comb
+= lenexp
.addr_i
.eq(lsbaddr
)
214 with m
.If(pi
.addr
.ok
& adrok_l
.qn
):
215 self
.set_rd_addr(m
, pi
.addr
.data
, lenexp
.lexp_o
)
216 comb
+= pi
.addr_ok_o
.eq(1) # acknowledge addr ok
217 sync
+= adrok_l
.s
.eq(1) # and pull "ack" latch
219 # if now in "ST" mode: likewise do the same but with "ST"
220 # to memory, acknowledge address, and send out LD data
221 with m
.If(st_active
.q
):
222 # set up LenExpander with the ST len and lower bits of addr
223 lsbaddr
, msbaddr
= self
.splitaddr(pi
.addr
.data
)
224 comb
+= lenexp
.len_i
.eq(pi
.data_len
)
225 comb
+= lenexp
.addr_i
.eq(lsbaddr
)
226 with m
.If(pi
.addr
.ok
):
227 self
.set_wr_addr(m
, pi
.addr
.data
, lenexp
.lexp_o
)
228 with m
.If(adrok_l
.qn
):
229 comb
+= pi
.addr_ok_o
.eq(1) # acknowledge addr ok
230 sync
+= adrok_l
.s
.eq(1) # and pull "ack" latch
232 # for LD mode, when addr has been "ok'd", assume that (because this
233 # is a "Memory" test-class) the memory read data is valid.
234 comb
+= reset_l
.s
.eq(0)
235 comb
+= reset_l
.r
.eq(0)
236 lddata
= Signal(self
.regwid
, reset_less
=True)
237 data
, ldok
= self
.get_rd_data(m
)
238 comb
+= lddata
.eq((data
& lenexp
.rexp_o
) >>
240 with m
.If(ld_active
.q
& adrok_l
.q
):
241 # shift data down before pushing out. requires masking
242 # from the *byte*-expanded version of LenExpand output
243 comb
+= pi
.ld
.data
.eq(lddata
) # put data out
244 comb
+= pi
.ld
.ok
.eq(ldok
) # indicate data valid
245 comb
+= reset_l
.s
.eq(ldok
) # reset mode after 1 cycle
247 # for ST mode, when addr has been "ok'd", wait for incoming "ST ok"
248 with m
.If(st_active
.q
& pi
.st
.ok
):
249 # shift data up before storing. lenexp *bit* version of mask is
250 # passed straight through as byte-level "write-enable" lines.
251 stdata
= Signal(self
.regwid
, reset_less
=True)
252 comb
+= stdata
.eq(pi
.st
.data
<< (lenexp
.addr_i
*8))
253 # TODO: replace with link to LoadStoreUnitInterface.x_store_data
254 # and also handle the ready/stall/busy protocol
255 stok
= self
.set_wr_data(m
, stdata
, lenexp
.lexp_o
)
256 sync
+= st_done
.s
.eq(1) # store done trigger
257 with m
.If(st_done
.q
):
258 comb
+= reset_l
.s
.eq(stok
) # reset mode after 1 cycle
260 # ugly hack, due to simultaneous addr req-go acknowledge
261 reset_delay
= Signal(reset_less
=True)
262 sync
+= reset_delay
.eq(reset_l
.q
)
263 with m
.If(reset_delay
):
264 comb
+= adrok_l
.r
.eq(1) # address reset
266 # after waiting one cycle (reset_l is "sync" mode), reset the port
267 with m
.If(reset_l
.q
):
268 comb
+= ld_active
.r
.eq(1) # leave the ST active for 1 cycle
269 comb
+= st_active
.r
.eq(1) # leave the ST active for 1 cycle
270 comb
+= reset_l
.r
.eq(1) # clear reset
271 comb
+= adrok_l
.r
.eq(1) # address reset
272 comb
+= st_done
.r
.eq(1) # store done reset
274 # monitor for an exception or the completion of LD.
275 with m
.If(self
.pi
.addr_exc_o
):
276 comb
+= busy_l
.r
.eq(1)
278 # however ST needs one cycle before busy is reset
279 #with m.If(self.pi.st.ok | self.pi.ld.ok):
280 with m
.If(reset_l
.s
):
281 comb
+= cyc_l
.s
.eq(1)
284 comb
+= cyc_l
.r
.eq(1)
285 comb
+= busy_l
.r
.eq(1)
287 # busy latch outputs to interface
288 comb
+= pi
.busy_o
.eq(busy_l
.q
)
293 yield from self
.pi
.ports()
296 class TestMemoryPortInterface(PortInterfaceBase
):
297 """TestMemoryPortInterface
299 This is a test class for simple verification of the LDSTCompUnit
300 and for the simple core, to be able to run unit tests rapidly and
301 with less other code in the way.
303 Versions of this which are *compatible* (conform with PortInterface)
304 will include augmented-Wishbone Bus versions, including ones that
305 connect to L1, L2, MMU etc. etc. however this is the "base lowest
306 possible version that complies with PortInterface".
309 def __init__(self
, regwid
=64, addrwid
=4):
310 super().__init
__(regwid
, addrwid
)
311 # hard-code memory addressing width to 6 bits
312 self
.mem
= TestMemory(regwid
, 5, granularity
=regwid
//8, init
=False)
314 def set_wr_addr(self
, m
, addr
, mask
):
315 lsbaddr
, msbaddr
= self
.splitaddr(addr
)
316 m
.d
.comb
+= self
.mem
.wrport
.addr
.eq(msbaddr
)
318 def set_rd_addr(self
, m
, addr
, mask
):
319 lsbaddr
, msbaddr
= self
.splitaddr(addr
)
320 m
.d
.comb
+= self
.mem
.rdport
.addr
.eq(msbaddr
)
322 def set_wr_data(self
, m
, data
, wen
):
323 m
.d
.comb
+= self
.mem
.wrport
.data
.eq(data
) # write st to mem
324 m
.d
.comb
+= self
.mem
.wrport
.en
.eq(wen
) # enable writes
327 def get_rd_data(self
, m
):
328 return self
.mem
.rdport
.data
, Const(1, 1)
330 def elaborate(self
, platform
):
331 m
= super().elaborate(platform
)
333 # add TestMemory as submodule
334 m
.submodules
.mem
= self
.mem
339 yield from super().ports()
342 class TestCachedMemoryPortInterface(PortInterfaceBase
):
343 """TestCacheMemoryPortInterface
345 This is a test class for simple verification of LDSTSplitter
346 conforming to PortInterface,
349 def __init__(self
, regwid
=64, addrwid
=4):
350 super().__init
__(regwid
, addrwid
)
351 # hard-code memory addressing width to 6 bits
354 def set_wr_addr(self
, m
, addr
, mask
):
355 lsbaddr
, msbaddr
= self
.splitaddr(addr
)
356 m
.d
.comb
+= self
.mem
.wrport
.addr
.eq(msbaddr
)
358 def set_rd_addr(self
, m
, addr
, mask
):
359 lsbaddr
, msbaddr
= self
.splitaddr(addr
)
360 m
.d
.comb
+= self
.mem
.rdport
.addr
.eq(msbaddr
)
362 def set_wr_data(self
, m
, data
, wen
):
363 m
.d
.comb
+= self
.mem
.wrport
.data
.eq(data
) # write st to mem
364 m
.d
.comb
+= self
.mem
.wrport
.en
.eq(wen
) # enable writes
367 def get_rd_data(self
, m
):
368 return self
.mem
.rdport
.data
, Const(1, 1)
370 def elaborate(self
, platform
):
371 m
= super().elaborate(platform
)
373 # add TestMemory as submodule
374 m
.submodules
.mem
= self
.mem
379 yield from super().ports()