Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
58322a1d2This file is pinned to the selected release. Download the original to open it in your design tool.
#
# This file is part of LiteX
#
# Copyright (c) 2019-2024 Florent Kermarrec <florent@enjoy-digital.fr>
# Copyright (c) 2024 MoTeC <www.motec.com.au>
# SPDX-License-Identifier: BSD-2-Clause
import unittest
from migen import *
from litex.gen import *
from litex.soc.cores.hyperbus import (
HyperRAM,
HyperRAMAXIFrontend,
HyperRAMAXILiteFrontend,
HyperRAMClkGen,
HyperRAMCore,
HyperRAMNativePort,
HyperRAMWishboneFrontend,
hyperam_ios_layout,
hyperram_ios_layout,
hyperram_phy_tx_layout,
)
from litex.soc.interconnect import axi, wishbone
from litex.soc.integration.soc import SoCBusHandler, SoCRegion
def c2bool(c):
return {"-": 1, "_": 0}[c]
class Pads: pass
class HyperRamPads:
def __init__(self, dw=8):
self.clk = Signal()
self.rst_n = Signal()
self.cs_n = Signal()
self.dq = Record([("oe", 1), ("o", dw), ("i", dw)])
self.rwds = Record([("oe", 1), ("o", dw//8), ("i", dw//8)])
class HyperRamSplitPads:
def __init__(self, dw=8):
self.clk = Signal()
self.rst_n = Signal()
self.cs_n = Signal()
self.dq_o = Signal(dw)
self.dq_oe = Signal()
self.dq_i = Signal(dw)
self.rwds_o = Signal(dw//8)
self.rwds_oe = Signal()
self.rwds_i = Signal(dw//8)
class HyperRAMAXIFrontendDUT(LiteXModule):
def __init__(self, id_width=4):
self.axi = axi.AXIInterface(data_width=32, address_width=32, id_width=id_width)
self.port = HyperRAMNativePort()
self.frontend = HyperRAMAXIFrontend(self.axi, self.port)
self.errors = 0
class HyperRAMAXILiteFrontendDUT(LiteXModule):
def __init__(self):
self.axi_lite = axi.AXILiteInterface(data_width=32, address_width=32)
self.port = HyperRAMNativePort()
self.frontend = HyperRAMAXILiteFrontend(self.axi_lite, self.port)
self.errors = 0
class HyperRAMWishboneFrontendDUT(LiteXModule):
def __init__(self):
self.wishbone = wishbone.Interface(
data_width = 32,
address_width = 32,
addressing = "word",
bursting = True,
)
self.port = HyperRAMNativePort()
self.frontend = HyperRAMWishboneFrontend(self.wishbone, self.port)
self.errors = 0
class HyperRAMCoreDUT(LiteXModule):
def __init__(self):
phy = Pads()
phy.data_width = 16
phy.ios = Record([("rst_n", 1), ("rwds_i", 2)])
self.core = HyperRAMCore(phy, latency=5, latency_mode="fixed")
self.bus = self.core.bus
def axi_aw_send(bus, addr, burst_len=0, burst_type=axi.BURST_INCR, size=2, id=0):
yield bus.aw.valid.eq(1)
yield bus.aw.addr.eq(addr)
yield bus.aw.burst.eq(burst_type)
yield bus.aw.len.eq(burst_len)
yield bus.aw.size.eq(size)
yield bus.aw.id.eq(id)
yield
while (yield bus.aw.ready) == 0:
yield
yield bus.aw.valid.eq(0)
def axi_w_send(bus, data, last, strb=0xf):
yield bus.w.valid.eq(1)
yield bus.w.data.eq(data)
yield bus.w.strb.eq(strb)
yield bus.w.last.eq(int(last))
yield
while (yield bus.w.ready) == 0:
yield
yield bus.w.valid.eq(0)
def axi_b_recv(bus, ready_delay=0):
for _ in range(ready_delay):
yield
yield bus.b.ready.eq(1)
yield
while (yield bus.b.valid) == 0:
yield
resp = (yield bus.b.resp)
bid = (yield bus.b.id)
yield bus.b.ready.eq(0)
yield
return resp, bid
def axi_ar_send(bus, addr, burst_len=0, burst_type=axi.BURST_INCR, size=2, id=0):
yield bus.ar.valid.eq(1)
yield bus.ar.addr.eq(addr)
yield bus.ar.burst.eq(burst_type)
yield bus.ar.len.eq(burst_len)
yield bus.ar.size.eq(size)
yield bus.ar.id.eq(id)
yield
while (yield bus.ar.ready) == 0:
yield
yield bus.ar.valid.eq(0)
def axi_r_recv_one(bus, ready_delay=0):
for _ in range(ready_delay):
yield
yield bus.r.ready.eq(1)
while (yield bus.r.valid) == 0:
yield
data = (yield bus.r.data)
resp = (yield bus.r.resp)
rid = (yield bus.r.id)
last = (yield bus.r.last)
yield bus.r.ready.eq(0)
yield
while (yield bus.r.valid):
yield
return data, resp, rid, last
def axi_write_burst(bus, addr, values, strbs=None, burst_type=axi.BURST_INCR, size=2, id=0, b_ready_delay=0):
if strbs is None:
strbs = [0xf]*len(values)
yield from axi_aw_send(bus, addr, burst_len=len(values) - 1, burst_type=burst_type, size=size, id=id)
for n, (value, strb) in enumerate(zip(values, strbs)):
yield from axi_w_send(bus, value, last=(n == len(values) - 1), strb=strb)
return (yield from axi_b_recv(bus, ready_delay=b_ready_delay))
def axi_read_burst(bus, addr, length, burst_type=axi.BURST_INCR, size=2, id=0, r_ready_delay=0):
yield from axi_ar_send(bus, addr, burst_len=length - 1, burst_type=burst_type, size=size, id=id)
data = []
for n in range(length):
data.append((yield from axi_r_recv_one(bus, ready_delay=r_ready_delay if n == 0 else 0)))
return data
@passive
def native_port_model(port, log, read_data=None, ready_delay=1):
if read_data is None:
read_data = {}
while True:
yield port.req_ready.eq(0)
yield port.rsp_valid.eq(0)
while not (yield port.req_valid):
yield
for _ in range(ready_delay):
yield
adr = (yield port.req_addr)
write = (yield port.req_write)
log.append({
"adr" : adr,
"we" : write,
"dat_w" : (yield port.req_wdata),
"sel" : (yield port.req_sel),
"burst" : (yield port.req_burst),
})
yield port.req_ready.eq(1)
yield
yield port.req_ready.eq(0)
if write:
yield port.rsp_valid.eq(1)
yield
yield port.rsp_valid.eq(0)
else:
while not (yield port.rsp_ready):
yield
yield port.rsp_rdata.eq(read_data.get(adr, 0x1000_0000 | adr))
yield port.rsp_valid.eq(1)
yield
yield port.rsp_valid.eq(0)
yield
class TestHyperRAM(unittest.TestCase):
def test_hyperram_clkgen_phase_pattern(self):
def generator(dut):
expected = [
(0, 0, 0, 0),
(1, 0, 1, 1),
(2, 0, 1, 0),
(3, 1, 0, 0),
(0, 0, 0, 0),
]
for phase, rise, clk, fall in expected:
self.assertEqual((yield dut.phase), phase)
self.assertEqual((yield dut.rise), rise)
self.assertEqual((yield dut.cd_hyperram.clk), clk)
self.assertEqual((yield dut.fall), fall)
yield
dut = HyperRAMClkGen()
run_simulation(dut, generator(dut))
def test_hyperram_layout_helpers_validate_data_width(self):
self.assertEqual(hyperram_ios_layout(8), hyperam_ios_layout(8))
self.assertEqual(hyperram_phy_tx_layout(16)[3], ("dq", 16))
with self.assertRaisesRegex(ValueError, "data buses"):
hyperram_ios_layout(12)
def test_hyperram_syntax(self):
pads = Record([("clk", 1), ("rst_n", 1), ("cs_n", 1), ("dq", 8), ("rwds", 1)])
hyperram = HyperRAM(pads)
pads = Record([("clk_p", 1), ("clk_n", 1), ("rst_n", 1), ("cs_n", 1), ("dq", 8), ("rwds", 1)])
hyperram = HyperRAM(pads)
pads = HyperRamSplitPads(dw=16)
hyperram = HyperRAM(pads)
def test_hyperram_rejects_invalid_pads(self):
pads = HyperRamPads(dw=16)
pads.rwds = Signal(1)
with self.assertRaisesRegex(ValueError, "RWDS width"):
HyperRAM(pads)
pads = HyperRamSplitPads(dw=8)
del pads.rwds_oe
with self.assertRaisesRegex(ValueError, "rwds"):
HyperRAM(pads)
pads = HyperRamSplitPads(dw=8)
del pads.clk
with self.assertRaisesRegex(ValueError, "clk"):
HyperRAM(pads)
pads = HyperRamSplitPads(dw=8)
del pads.clk
pads.clk_p = Signal()
with self.assertRaisesRegex(ValueError, "clk_p and clk_n"):
HyperRAM(pads)
def test_hyperram_rejects_invalid_parameters(self):
with self.assertRaisesRegex(ValueError, "latency"):
HyperRAM(HyperRamPads(), latency=2)
with self.assertRaisesRegex(ValueError, "latency"):
HyperRAM(HyperRamPads(), latency=8)
with self.assertRaisesRegex(ValueError, "latency mode"):
HyperRAM(HyperRamPads(), latency_mode="invalid")
with self.assertRaisesRegex(ValueError, "clock ratio"):
HyperRAM(HyperRamPads(), clk_ratio="1:1")
with self.assertRaisesRegex(ValueError, "bus standard"):
HyperRAM(HyperRamPads(), bus_standard="avalon")
with self.assertRaisesRegex(ValueError, "AXI ID width"):
HyperRAM(HyperRamPads(), bus_standard="axi", axi_id_width=0)
def test_hyperram_bus_standard_interfaces(self):
self.assertIsInstance(HyperRAM(HyperRamPads(), with_csr=False).bus, wishbone.Interface)
self.assertIsInstance(
HyperRAM(HyperRamPads(), bus_standard="axi-lite", with_csr=False).bus,
axi.AXILiteInterface)
hyperram = HyperRAM(HyperRamPads(), bus_standard="axi", axi_id_width=4, with_csr=False)
self.assertIsInstance(hyperram.bus, axi.AXIInterface)
self.assertEqual(hyperram.bus.id_width, 4)
def test_hyperram_wishbone_write_ack_is_data_phase(self):
def generator(dut):
yield dut.bus.cyc.eq(1)
yield dut.bus.stb.eq(1)
yield dut.bus.we.eq(1)
yield dut.bus.adr.eq(0x1234)
yield dut.bus.dat_w.eq(0xdeadbeef)
yield dut.bus.sel.eq(0xf)
for _ in range(8):
yield
self.assertEqual((yield dut.bus.ack), 0)
ack_seen = False
for _ in range(128):
yield
if (yield dut.bus.ack):
ack_seen = True
break
self.assertTrue(ack_seen)
yield dut.bus.cyc.eq(0)
yield dut.bus.stb.eq(0)
yield dut.bus.we.eq(0)
yield
dut = HyperRAM(HyperRamPads(), latency=5, latency_mode="fixed")
run_simulation(dut, generator(dut))
def test_hyperram_wishbone_frontend_registers_burst_overlap(self):
def generator(dut):
yield dut.wishbone.cyc.eq(1)
yield dut.wishbone.stb.eq(1)
yield dut.wishbone.we.eq(0)
yield dut.wishbone.adr.eq(0)
yield dut.wishbone.cti.eq(wishbone.CTI_BURST_INCREMENTING)
yield dut.port.req_ready.eq(1)
yield
self.assertEqual((yield dut.port.req_valid), 1)
yield dut.port.req_ready.eq(0)
yield dut.wishbone.adr.eq(1)
yield dut.port.rsp_valid.eq(1)
yield dut.port.req_ready.eq(1)
yield
self.assertEqual((yield dut.wishbone.ack), 1)
self.assertEqual((yield dut.port.req_valid), 0)
yield dut.port.rsp_valid.eq(0)
yield dut.port.req_ready.eq(1)
yield
self.assertEqual((yield dut.port.req_valid), 1)
self.assertEqual((yield dut.port.req_addr), 1)
yield
dut = HyperRAMWishboneFrontendDUT()
run_simulation(dut, generator(dut))
def test_hyperram_wishbone_write_burst_uses_single_command(self):
command_starts = []
def fpga_gen(dut):
values = [0x01234567, 0x89abcdef, 0xdeadbeef, 0xc0ffee00]
yield dut.bus.cyc.eq(1)
yield dut.bus.stb.eq(1)
yield dut.bus.we.eq(1)
yield dut.bus.sel.eq(0xf)
yield dut.bus.adr.eq(0)
yield dut.bus.dat_w.eq(values[0])
yield dut.bus.cti.eq(wishbone.CTI_BURST_INCREMENTING)
for n, value in enumerate(values):
for _ in range(256):
if (yield dut.bus.ack):
break
yield
else:
self.fail("Wishbone write burst timed out.")
if n == (len(values) - 1):
break
yield dut.bus.adr.eq(n + 1)
yield dut.bus.dat_w.eq(values[n + 1])
yield dut.bus.cti.eq(
wishbone.CTI_BURST_END if n == (len(values) - 2) else
wishbone.CTI_BURST_INCREMENTING)
yield
yield dut.bus.cyc.eq(0)
yield dut.bus.stb.eq(0)
yield dut.bus.we.eq(0)
yield dut.bus.cti.eq(wishbone.CTI_BURST_NONE)
for _ in range(64):
yield
def monitor(dut):
was_cmd_address = 0
for cycle in range(512):
is_cmd_address = (yield dut.core.fsm.state) == cmd_address
if is_cmd_address and not was_cmd_address:
command_starts.append(cycle)
was_cmd_address = is_cmd_address
yield
dut = HyperRAM(HyperRamPads(), latency=5, latency_mode="fixed")
cmd_address = dut.core.fsm.encoding["CMD-ADDRESS"]
run_simulation(dut, [fpga_gen(dut), monitor(dut)])
self.assertEqual(len(command_starts), 1)
def test_hyperram_wishbone_classic_adjacent_writes_use_single_command(self):
command_starts = []
def fpga_gen(dut):
values = [0x01234567, 0x89abcdef, 0xdeadbeef, 0xc0ffee00]
yield dut.bus.cyc.eq(1)
yield dut.bus.stb.eq(1)
yield dut.bus.we.eq(1)
yield dut.bus.sel.eq(0xf)
yield dut.bus.cti.eq(wishbone.CTI_BURST_NONE)
yield dut.bus.adr.eq(0)
yield dut.bus.dat_w.eq(values[0])
for n, value in enumerate(values):
for _ in range(256):
if (yield dut.bus.ack):
break
yield
else:
self.fail("Wishbone classic write timed out.")
if n == (len(values) - 1):
break
yield dut.bus.adr.eq(n + 1)
yield dut.bus.dat_w.eq(values[n + 1])
yield
yield dut.bus.cyc.eq(0)
yield dut.bus.stb.eq(0)
yield dut.bus.we.eq(0)
yield
def monitor(dut):
was_cmd_address = 0
for cycle in range(1024):
is_cmd_address = (yield dut.core.fsm.state) == cmd_address
if is_cmd_address and not was_cmd_address:
command_starts.append(cycle)
was_cmd_address = is_cmd_address
yield
dut = HyperRAM(HyperRamPads(), latency=5, latency_mode="fixed")
cmd_address = dut.core.fsm.encoding["CMD-ADDRESS"]
run_simulation(dut, [fpga_gen(dut), monitor(dut)])
self.assertEqual(len(command_starts), 1)
def test_hyperram_wishbone_classic_non_adjacent_writes_start_separate_commands(self):
command_starts = []
def fpga_gen(dut):
values = [0x01234567, 0x89abcdef, 0xdeadbeef, 0xc0ffee00]
yield dut.bus.cyc.eq(1)
yield dut.bus.stb.eq(1)
yield dut.bus.we.eq(1)
yield dut.bus.sel.eq(0xf)
yield dut.bus.cti.eq(wishbone.CTI_BURST_NONE)
yield dut.bus.adr.eq(0)
yield dut.bus.dat_w.eq(values[0])
for n, value in enumerate(values):
for _ in range(256):
if (yield dut.bus.ack):
break
yield
else:
self.fail("Wishbone classic write timed out.")
if n == (len(values) - 1):
break
yield dut.bus.adr.eq(2*(n + 1))
yield dut.bus.dat_w.eq(values[n + 1])
yield
yield dut.bus.cyc.eq(0)
yield dut.bus.stb.eq(0)
yield dut.bus.we.eq(0)
yield
def monitor(dut):
was_cmd_address = 0
for cycle in range(1024):
is_cmd_address = (yield dut.core.fsm.state) == cmd_address
if is_cmd_address and not was_cmd_address:
command_starts.append(cycle)
was_cmd_address = is_cmd_address
yield
dut = HyperRAM(HyperRamPads(), latency=5, latency_mode="fixed")
cmd_address = dut.core.fsm.encoding["CMD-ADDRESS"]
run_simulation(dut, [fpga_gen(dut), monitor(dut)])
self.assertEqual(len(command_starts), 4)
def test_hyperram_wishbone_classic_reads_can_auto_continue(self):
command_starts = []
def fpga_gen(dut):
yield dut.bus.cyc.eq(1)
yield dut.bus.stb.eq(1)
yield dut.bus.we.eq(0)
yield dut.bus.sel.eq(0xf)
yield dut.bus.cti.eq(wishbone.CTI_BURST_NONE)
yield dut.bus.adr.eq(0)
for n in range(4):
for _ in range(256):
if (yield dut.bus.ack):
break
yield
else:
self.fail("Wishbone classic read timed out.")
if n == 3:
break
yield dut.bus.adr.eq(n + 1)
yield
yield dut.bus.cyc.eq(0)
yield dut.bus.stb.eq(0)
yield
@passive
def hyperram_gen(dut):
dq = 0
while True:
yield dut.core.source.ready.eq(1)
if (yield dut.core.source.valid) and (yield dut.core.source.dat_r):
yield dut.core.sink.valid.eq(1)
yield dut.core.sink.dq.eq(dq)
dq = (dq + 1) & 0xffff
else:
yield dut.core.sink.valid.eq(0)
yield
def monitor(dut):
was_cmd_address = 0
for cycle in range(1024):
is_cmd_address = (yield dut.core.fsm.state) == cmd_address
if is_cmd_address and not was_cmd_address:
command_starts.append(cycle)
was_cmd_address = is_cmd_address
yield
dut = HyperRAMCoreDUT()
cmd_address = dut.core.fsm.encoding["CMD-ADDRESS"]
run_simulation(dut, [fpga_gen(dut), hyperram_gen(dut), monitor(dut)])
self.assertEqual(len(command_starts), 1)
def test_hyperram_soc_bus_kwargs_keep_native_slave(self):
cases = [
("wishbone", wishbone.Interface),
("axi-lite", axi.AXILiteInterface),
("axi", axi.AXIInterface),
]
for bus_standard, interface_cls in cases:
with self.subTest(bus_standard=bus_standard):
soc_bus = SoCBusHandler(standard=bus_standard)
if bus_standard == "axi":
soc_bus.add_master("cpu", axi.AXIInterface(data_width=32, address_width=32, id_width=4))
hyperram = HyperRAM(HyperRamPads(),
with_csr = False,
**soc_bus.get_bus_standard_kwargs(with_axi_id_width=True))
soc_bus.add_slave("hyperram", hyperram.bus, SoCRegion(origin=0x00000000, size=0x1000))
self.assertIsInstance(hyperram.bus, interface_cls)
self.assertIs(soc_bus.slaves["hyperram"], hyperram.bus)
if bus_standard == "axi":
self.assertEqual(hyperram.bus.id_width, 4)
def test_hyperram_axi_frontend_write_incr_burst(self):
log = []
values = [0x01234567, 0x89abcdef, 0xdeadbeef, 0xc0ffee00]
strbs = [0xf, 0x3, 0xc, 0xf]
def generator(dut):
resp, bid = yield from axi_write_burst(
dut.axi,
addr = 0x1000,
values= values,
strbs = strbs,
id = 5)
self.assertEqual(resp, axi.RESP_OKAY)
self.assertEqual(bid, 5)
dut = HyperRAMAXIFrontendDUT(id_width=4)
run_simulation(dut, [generator(dut), native_port_model(dut.port, log)])
self.assertEqual([entry["adr"] for entry in log], [0x400, 0x401, 0x402, 0x403])
self.assertEqual([entry["dat_w"] for entry in log], values)
self.assertEqual([entry["sel"] for entry in log], strbs)
self.assertEqual([entry["we"] for entry in log], [1, 1, 1, 1])
self.assertEqual([entry["burst"] for entry in log], [1, 1, 1, 0])
def test_hyperram_axi_frontend_read_incr_burst(self):
log = []
read_data = {
0x20: 0x11111111,
0x21: 0x22222222,
0x22: 0x33333333,
0x23: 0x44444444,
}
def generator(dut):
beats = yield from axi_read_burst(dut.axi, addr=0x80, length=4, id=6)
self.assertEqual([beat[0] for beat in beats], [
read_data[0x20],
read_data[0x21],
read_data[0x22],
read_data[0x23],
])
self.assertEqual([beat[1] for beat in beats], [axi.RESP_OKAY]*4)
self.assertEqual([beat[2] for beat in beats], [6]*4)
self.assertEqual([beat[3] for beat in beats], [0, 0, 0, 1])
dut = HyperRAMAXIFrontendDUT(id_width=4)
run_simulation(dut, [generator(dut), native_port_model(dut.port, log, read_data)])
self.assertEqual([entry["adr"] for entry in log], [0x20, 0x21, 0x22, 0x23])
self.assertEqual([entry["we"] for entry in log], [0, 0, 0, 0])
self.assertEqual([entry["burst"] for entry in log], [1, 1, 1, 0])
def test_hyperram_axi_frontend_wrap_and_fixed_are_decomposed(self):
log = []
def generator(dut):
resp, bid = yield from axi_write_burst(
dut.axi,
addr = 0x108,
values = [0x10, 0x11, 0x12, 0x13],
burst_type = axi.BURST_WRAP,
id = 1)
self.assertEqual(resp, axi.RESP_OKAY)
self.assertEqual(bid, 1)
resp, bid = yield from axi_write_burst(
dut.axi,
addr = 0x200,
values = [0x20, 0x21, 0x22],
burst_type = axi.BURST_FIXED,
id = 2)
self.assertEqual(resp, axi.RESP_OKAY)
self.assertEqual(bid, 2)
dut = HyperRAMAXIFrontendDUT(id_width=4)
run_simulation(dut, [generator(dut), native_port_model(dut.port, log)])
self.assertEqual([entry["adr"] for entry in log], [
0x42, 0x43, 0x40, 0x41,
0x80, 0x80, 0x80,
])
self.assertEqual([entry["burst"] for entry in log], [0]*7)
def test_hyperram_axi_frontend_rejects_unsupported_requests(self):
log = []
def generator(dut):
resp, bid = yield from axi_write_burst(
dut.axi,
addr = 0x100,
values= [0x12345678],
size = 3,
id = 3)
self.assertEqual(resp, axi.RESP_SLVERR)
self.assertEqual(bid, 3)
beats = yield from axi_read_burst(
dut.axi,
addr = 0x100,
length = 1,
burst_type = axi.BURST_RESERVED,
id = 4)
self.assertEqual(beats, [(0, axi.RESP_SLVERR, 4, 1)])
dut = HyperRAMAXIFrontendDUT(id_width=4)
run_simulation(dut, [generator(dut), native_port_model(dut.port, log)])
self.assertEqual(log, [])
def test_hyperram_axi_frontend_holds_responses_under_backpressure(self):
log = []
read_data = {0x40: 0xfeedface}
def generator(dut):
resp, bid = yield from axi_write_burst(
dut.axi,
addr = 0x100,
values = [0xa5a5a5a5],
id = 7,
b_ready_delay = 4)
self.assertEqual(resp, axi.RESP_OKAY)
self.assertEqual(bid, 7)
yield from axi_ar_send(dut.axi, addr=0x100, id=8)
for _ in range(4):
self.assertEqual((yield dut.axi.r.ready), 0)
yield
data, resp, rid, last = yield from axi_r_recv_one(dut.axi)
self.assertEqual((data, resp, rid, last), (0xfeedface, axi.RESP_OKAY, 8, 1))
dut = HyperRAMAXIFrontendDUT(id_width=4)
run_simulation(dut, [generator(dut), native_port_model(dut.port, log, read_data)])
self.assertEqual([entry["adr"] for entry in log], [0x40, 0x40])
def test_hyperram_axi_lite_frontend_single_accesses(self):
log = []
read_data = {0x41: 0x1234abcd}
def generator(dut):
resp = yield from dut.axi_lite.write(0x100, 0xdeadbeef, strb=0b0101)
self.assertEqual(resp, axi.RESP_OKAY)
data, resp = yield from dut.axi_lite.read(0x104)
self.assertEqual((data, resp), (0x1234abcd, axi.RESP_OKAY))
dut = HyperRAMAXILiteFrontendDUT()
run_simulation(dut, [generator(dut), native_port_model(dut.port, log, read_data)])
self.assertEqual([entry["adr"] for entry in log], [0x40, 0x41])
self.assertEqual([entry["we"] for entry in log], [1, 0])
self.assertEqual(log[0]["dat_w"], 0xdeadbeef)
self.assertEqual(log[0]["sel"], 0b0101)
self.assertEqual([entry["burst"] for entry in log], [0, 0])
def test_hyperram_write_latency_5_2x(self):
def fpga_gen(dut):
yield from dut.bus.write(0x1234, 0xdeadbeef, sel=0b1001)
yield
def hyperram_gen(dut):
clk = "_______--__--__--__--__--__--__--__--__--__--__--__--__--__--_______"
cs_n = "----__________________________________________________________------"
dq_oe = "______------------____________________________________--------______"
dq_o = "0000002000048d0000000000000000000000000000000000000000deadbeef000000"
rwds_oe = "______________________________________________________--------______"
rwds_o = "________________________________________________________----________"
yield
for i in range(len(clk)):
self.assertEqual(c2bool(clk[i]), (yield dut.pads.clk))
self.assertEqual(c2bool(cs_n[i]), (yield dut.pads.cs_n))
self.assertEqual(c2bool(dq_oe[i]), (yield dut.pads.dq.oe))
if (yield dut.pads.dq.oe):
self.assertEqual(int(dq_o[2*(i//2):2*(i//2)+2], 16), (yield dut.pads.dq.o))
self.assertEqual(c2bool(rwds_oe[i]), (yield dut.pads.rwds.oe))
self.assertEqual(c2bool(rwds_o[i]), (yield dut.pads.rwds.o))
yield
dut = HyperRAM(HyperRamPads(dw=8), latency=5, latency_mode="fixed")
run_simulation(dut, [fpga_gen(dut), hyperram_gen(dut)], vcd_name="sim.vcd")
def test_hyperram_write_latency_5_2x_sys2x(self):
def fpga_gen(dut):
yield from dut.bus.write(0x1234, 0xdeadbeef, sel=0b1001)
yield
def hyperram_gen(dut):
clk = "________________--__--__--__--__--__--__--__--__--__--__--__--__--__--_______"
cs_n = "_------------__________________________________________________________------"
dq_oe = "_______________------------____________________________________--------______"
dq_o = "0000000000000002000048d0000000000000000000000000000000000000000deadbeef000000"
rwds_oe = "_______________________________________________________________--------______"
rwds_o = "_________________________________________________________________----________"
for i in range(len(clk)):
self.assertEqual(c2bool(clk[i]), (yield dut.pads.clk))
self.assertEqual(c2bool(cs_n[i]), (yield dut.pads.cs_n))
self.assertEqual(c2bool(dq_oe[i]), (yield dut.pads.dq.oe))
#if (yield dut.pads.dq.oe):
# self.assertEqual(int(dq_o[2*(i//2):2*(i//2)+2], 16), (yield dut.pads.dq.o))
self.assertEqual(c2bool(rwds_oe[i]), (yield dut.pads.rwds.oe))
self.assertEqual(c2bool(rwds_o[i]), (yield dut.pads.rwds.o))
yield
for i in range(128):
yield
dut = HyperRAM(HyperRamPads(), latency=5, latency_mode="fixed", clk_ratio="2:1")
generators = {
"sys" : fpga_gen(dut),
"sys2x" : hyperram_gen(dut),
}
clocks = {
"sys" : 4,
"sys2x" : 2,
}
run_simulation(dut, generators, clocks, vcd_name="sim.vcd")
def test_hyperram_write_latches_cti(self):
def fpga_gen(dut):
yield from dut.bus.write(0x1234, 0xdeadbeef, sel=0b1001, cti=0b010)
yield
self.assertEqual((yield dut.core.bus_cti), 0b010)
yield
def hyperram_gen(dut):
clk = "_______--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--_______"
cs_n = "----__________________________________________________________________------"
dq_oe = "______------------____________________________________________--------______"
dq_o = "0000002000048d000000000000000000000000000000000000000000000000deadbeef000000"
rwds_oe = "______________________________________________________________--------______"
rwds_o = "________________________________________________________________----________"
yield
for i in range(len(clk)):
self.assertEqual(c2bool(clk[i]), (yield dut.pads.clk))
self.assertEqual(c2bool(cs_n[i]), (yield dut.pads.cs_n))
self.assertEqual(c2bool(dq_oe[i]), (yield dut.pads.dq.oe))
if (yield dut.pads.dq.oe):
self.assertEqual(int(dq_o[2*(i//2):2*(i//2)+2], 16), (yield dut.pads.dq.o))
self.assertEqual(c2bool(rwds_oe[i]), (yield dut.pads.rwds.oe))
self.assertEqual(c2bool(rwds_o[i]), (yield dut.pads.rwds.o))
yield
dut = HyperRAM(HyperRamPads(), latency=6, latency_mode="fixed")
run_simulation(dut, [fpga_gen(dut), hyperram_gen(dut)], vcd_name="sim.vcd")
def test_hyperram_write_latency_6_2x(self):
def fpga_gen(dut):
yield from dut.bus.write(0x1234, 0xdeadbeef, sel=0b1001)
yield
def hyperram_gen(dut):
clk = "_______--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--_______"
cs_n = "----__________________________________________________________________------"
dq_oe = "______------------____________________________________________--------______"
dq_o = "0000002000048d000000000000000000000000000000000000000000000000deadbeef000000"
rwds_oe = "______________________________________________________________--------______"
rwds_o = "________________________________________________________________----________"
yield
for i in range(len(clk)):
self.assertEqual(c2bool(clk[i]), (yield dut.pads.clk))
self.assertEqual(c2bool(cs_n[i]), (yield dut.pads.cs_n))
self.assertEqual(c2bool(dq_oe[i]), (yield dut.pads.dq.oe))
if (yield dut.pads.dq.oe):
self.assertEqual(int(dq_o[2*(i//2):2*(i//2)+2], 16), (yield dut.pads.dq.o))
self.assertEqual(c2bool(rwds_oe[i]), (yield dut.pads.rwds.oe))
self.assertEqual(c2bool(rwds_o[i]), (yield dut.pads.rwds.o))
yield
dut = HyperRAM(HyperRamPads(), latency=6, latency_mode="fixed")
run_simulation(dut, [fpga_gen(dut), hyperram_gen(dut)], vcd_name="sim.vcd")
def test_hyperram_write_latency_7_2x(self):
def fpga_gen(dut):
yield from dut.bus.write(0x1234, 0xdeadbeef, sel=0b1001)
yield
def hyperram_gen(dut):
clk = "_______--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--_______"
cs_n = "----__________________________________________________________________________------"
dq_oe = "______------------____________________________________________________--------______"
dq_o = "0000002000048d00000000000000000000000000000000000000000000000000000000deadbeef000000"
rwds_oe = "______________________________________________________________________--------______"
rwds_o = "________________________________________________________________________----________"
yield
for i in range(len(clk)):
self.assertEqual(c2bool(clk[i]), (yield dut.pads.clk))
self.assertEqual(c2bool(cs_n[i]), (yield dut.pads.cs_n))
self.assertEqual(c2bool(dq_oe[i]), (yield dut.pads.dq.oe))
if (yield dut.pads.dq.oe):
self.assertEqual(int(dq_o[2*(i//2):2*(i//2)+2], 16), (yield dut.pads.dq.o))
self.assertEqual(c2bool(rwds_oe[i]), (yield dut.pads.rwds.oe))
self.assertEqual(c2bool(rwds_o[i]), (yield dut.pads.rwds.o))
yield
dut = HyperRAM(HyperRamPads(), latency=7, latency_mode="fixed")
run_simulation(dut, [fpga_gen(dut), hyperram_gen(dut)], vcd_name="sim.vcd")
def test_hyperram_write_latency_7_1x(self):
def fpga_gen(dut):
yield from dut.bus.write(0x1234, 0xdeadbeef, sel=0b1001)
yield
def hyperram_gen(dut):
clk = "_______--__--__--__--__--__--__--__--__--__--__--_______"
cs_n = "----______________________________________________------"
dq_oe = "______------------________________________--------______"
dq_o = "0000002000048d0000000000000000000000000000deadbeef000000"
rwds_oe = "__________________________________________--------______"
rwds_o = "____________________________________________----________"
yield
for i in range(len(clk)):
self.assertEqual(c2bool(clk[i]), (yield dut.pads.clk))
self.assertEqual(c2bool(cs_n[i]), (yield dut.pads.cs_n))
self.assertEqual(c2bool(dq_oe[i]), (yield dut.pads.dq.oe))
if (yield dut.pads.dq.oe):
self.assertEqual(int(dq_o[2*(i//2):2*(i//2)+2], 16), (yield dut.pads.dq.o))
self.assertEqual(c2bool(rwds_oe[i]), (yield dut.pads.rwds.oe))
self.assertEqual(c2bool(rwds_o[i]), (yield dut.pads.rwds.o))
yield
dut = HyperRAM(HyperRamPads(), latency=7, latency_mode="variable")
run_simulation(dut, [fpga_gen(dut), hyperram_gen(dut)], vcd_name="sim.vcd")
def test_hyperram_read_latency_5_2x(self):
def fpga_gen(dut):
dat = yield from dut.bus.read(0x1234)
self.assertEqual(dat, 0xdeadbeef)
def hyperram_gen(dut):
clk = "_______--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--_____"
cs_n = "----______________________________________________________________________________----"
dq_oe = "______------------____________________________________________________________________"
dq_o = "000000a000048d000000000000000000000000000000000000000000000000000000000000000000000000"
dq_i = "000000000000000000000000000000000000000000000000000000deadbeefcafefade0000000000000000"
rwds_oe = "______________________________________________________________________________________"
rwds_i = "______________________________________________________--__--__--__--__________________"
yield
for i in range(len(clk)):
yield dut.pads.dq.i.eq(int(dq_i[2*(i//2):2*(i//2)+2], 16))
yield dut.pads.rwds.i.eq(c2bool(rwds_i[i]))
self.assertEqual(c2bool(clk[i]), (yield dut.pads.clk))
self.assertEqual(c2bool(cs_n[i]), (yield dut.pads.cs_n))
self.assertEqual(c2bool(dq_oe[i]), (yield dut.pads.dq.oe))
if (yield dut.pads.dq.oe):
self.assertEqual(int(dq_o[2*(i//2):2*(i//2)+2], 16), (yield dut.pads.dq.o))
self.assertEqual(c2bool(rwds_oe[i]), (yield dut.pads.rwds.oe))
yield
dut = HyperRAM(HyperRamPads(), latency=5, latency_mode="fixed")
run_simulation(dut, [fpga_gen(dut), hyperram_gen(dut)], vcd_name="sim.vcd")
def test_hyperram_read_latency_6_2x(self):
def fpga_gen(dut):
dat = yield from dut.bus.read(0x1234)
self.assertEqual(dat, 0xdeadbeef)
def hyperram_gen(dut):
clk = "_______--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--_____"
cs_n = "----______________________________________________________________________________________----"
dq_oe = "______------------____________________________________________________________________________"
dq_o = "000000a000048d00000000000000000000000000000000000000000000000000000000000000000000000000000000"
dq_i = "00000000000000000000000000000000000000000000000000000000000000deadbeefcafefade0000000000000000"
rwds_oe = "______________________________________________________________________________________________"
rwds_i = "______________________________________________________________--__--__--__--__________________"
yield
for i in range(len(clk)):
yield dut.pads.dq.i.eq(int(dq_i[2*(i//2):2*(i//2)+2], 16))
yield dut.pads.rwds.i.eq(c2bool(rwds_i[i]))
self.assertEqual(c2bool(clk[i]), (yield dut.pads.clk))
self.assertEqual(c2bool(cs_n[i]), (yield dut.pads.cs_n))
self.assertEqual(c2bool(dq_oe[i]), (yield dut.pads.dq.oe))
if (yield dut.pads.dq.oe):
self.assertEqual(int(dq_o[2*(i//2):2*(i//2)+2], 16), (yield dut.pads.dq.o))
self.assertEqual(c2bool(rwds_oe[i]), (yield dut.pads.rwds.oe))
yield
dut = HyperRAM(HyperRamPads(), latency=6, latency_mode="fixed")
run_simulation(dut, [fpga_gen(dut), hyperram_gen(dut)], vcd_name="sim.vcd")
def test_hyperram_read_latency_7_2x(self):
def fpga_gen(dut):
dat = yield from dut.bus.read(0x1234)
self.assertEqual(dat, 0xdeadbeef)
def hyperram_gen(dut):
clk = "_______--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__--_____"
cs_n = "----______________________________________________________________________________________________----"
dq_oe = "______------------____________________________________________________________________________________"
dq_o = "000000a000048d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
dq_i = "0000000000000000000000000000000000000000000000000000000000000000000000deadbeefcafefade0000000000000000"
rwds_oe = "______________________________________________________________________________________________________"
rwds_i = "______________________________________________________________________--__--__--__--__________________"
yield
for i in range(len(clk)):
yield dut.pads.dq.i.eq(int(dq_i[2*(i//2):2*(i//2)+2], 16))
yield dut.pads.rwds.i.eq(c2bool(rwds_i[i]))
self.assertEqual(c2bool(clk[i]), (yield dut.pads.clk))
self.assertEqual(c2bool(cs_n[i]), (yield dut.pads.cs_n))
self.assertEqual(c2bool(dq_oe[i]), (yield dut.pads.dq.oe))
if (yield dut.pads.dq.oe):
self.assertEqual(int(dq_o[2*(i//2):2*(i//2)+2], 16), (yield dut.pads.dq.o))
self.assertEqual(c2bool(rwds_oe[i]), (yield dut.pads.rwds.oe))
yield
dut = HyperRAM(HyperRamPads(), latency=7, latency_mode="fixed")
run_simulation(dut, [fpga_gen(dut), hyperram_gen(dut)], vcd_name="sim.vcd")
def test_hyperram_read_latency_7_1x(self):
def fpga_gen(dut):
dat = yield from dut.bus.read(0x1234)
self.assertEqual(dat, 0xdeadbeef)
def hyperram_gen(dut):
clk = "_______--__--__--__--__--__--__--__--__--__--__--__--__--__--__--__-______"
cs_n = "----________________________________________________________________------"
dq_oe = "______------------________________________________________________________"
dq_o = "000000a000048d000000000000000000000000000000000000000000000000000000000000"
dq_i = "0000000000000000000000000000000000000000deadbeefcafefade000000000000000000"
rwds_oe = "__________________________________________________________________________"
rwds_i = "________________________________________--__--__--__--____________________"
yield
for i in range(len(clk)):
yield dut.pads.dq.i.eq(int(dq_i[2*(i//2):2*(i//2)+2], 16))
yield dut.pads.rwds.i.eq(c2bool(rwds_i[i]))
self.assertEqual(c2bool(clk[i]), (yield dut.pads.clk))
self.assertEqual(c2bool(cs_n[i]), (yield dut.pads.cs_n))
self.assertEqual(c2bool(dq_oe[i]), (yield dut.pads.dq.oe))
if (yield dut.pads.dq.oe):
self.assertEqual(int(dq_o[2*(i//2):2*(i//2)+2], 16), (yield dut.pads.dq.o))
self.assertEqual(c2bool(rwds_oe[i]), (yield dut.pads.rwds.oe))
yield
dut = HyperRAM(HyperRamPads(), latency=7, latency_mode="variable")
run_simulation(dut, [fpga_gen(dut), hyperram_gen(dut)], vcd_name="sim.vcd")
def test_hyperram_reg_write(self):
def fpga_gen(dut):
yield dut.core.reg.adr.eq(2)
yield dut.core.reg.dat_w.eq(0x1234)
yield
yield dut.core.reg.stb.eq(1)
yield dut.core.reg.we.eq(1)
while (yield dut.core.reg.ack) == 0:
yield
yield dut.core.reg.stb.eq(0)
def hyperram_gen(dut):
clk = "___________--__--__--__--___________"
cs_n = "--------__________________----------"
dq_oe = "__________----------------__________"
dq_o = "000000000060000100000012340000000000"
rwds_oe = "____________________________________"
rwds_o = "____________________________________"
yield
for i in range(len(clk)):
self.assertEqual(c2bool(clk[i]), (yield dut.pads.clk))
self.assertEqual(c2bool(cs_n[i]), (yield dut.pads.cs_n))
self.assertEqual(c2bool(dq_oe[i]), (yield dut.pads.dq.oe))
if (yield dut.pads.dq.oe):
self.assertEqual(int(dq_o[2*(i//2):2*(i//2)+2], 16), (yield dut.pads.dq.o))
self.assertEqual(c2bool(rwds_oe[i]), (yield dut.pads.rwds.oe))
self.assertEqual(c2bool(rwds_o[i]), (yield dut.pads.rwds.o))
yield
dut = HyperRAM(HyperRamPads(), with_csr=False)
run_simulation(dut, [fpga_gen(dut), hyperram_gen(dut)], vcd_name="sim.vcd")#