bslathi19/cocotbext-axi
1
0
Fork 0
Code Issues Actions Packages Projects Releases 5 Wiki Activity

Rename byte_width to byte_lanes

Browse Source
This commit is contained in:
Alex Forencich
2021-04-12 15:08:30 -07:00
parent 8bbabd92df
commit 82853b31ff
6 changed files with 91 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
cocotbext/axi/axi_master.py
View File

@@ -166,23 +166,23 @@ class AxiMasterWrite(Reset):
self.width = len(self.w_channel.bus.wdata) self.width = len(self.w_channel.bus.wdata)
self.byte_size = 8 self.byte_size = 8
self.byte_width = self.width // self.byte_size self.byte_lanes = self.width // self.byte_size
self.strb_mask = 2**self.byte_width-1 self.strb_mask = 2**self.byte_lanes-1
self.max_burst_len = max(min(max_burst_len, 256), 1) self.max_burst_len = max(min(max_burst_len, 256), 1)
self.max_burst_size = (self.byte_width-1).bit_length() self.max_burst_size = (self.byte_lanes-1).bit_length()
self.log.info("AXI master configuration:") self.log.info("AXI master configuration:")
self.log.info(" Address width: %d bits", len(self.aw_channel.bus.awaddr)) self.log.info(" Address width: %d bits", len(self.aw_channel.bus.awaddr))
self.log.info(" ID width: %d bits", len(self.aw_channel.bus.awid)) self.log.info(" ID width: %d bits", len(self.aw_channel.bus.awid))
self.log.info(" Byte size: %d bits", self.byte_size) self.log.info(" Byte size: %d bits", self.byte_size)
self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_width) self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_lanes)
self.log.info(" Max burst size: %d (%d bytes)", self.max_burst_size, 2**self.max_burst_size) self.log.info(" Max burst size: %d (%d bytes)", self.max_burst_size, 2**self.max_burst_size)
self.log.info(" Max burst length: %d cycles (%d bytes)", self.log.info(" Max burst length: %d cycles (%d bytes)",
self.max_burst_len, self.max_burst_len*self.byte_width) self.max_burst_len, self.max_burst_len*self.byte_lanes)
assert self.byte_width == len(self.w_channel.bus.wstrb) assert self.byte_lanes == len(self.w_channel.bus.wstrb)
assert self.byte_width * self.byte_size == self.width assert self.byte_lanes * self.byte_size == self.width
assert len(self.b_channel.bus.bid) == len(self.aw_channel.bus.awid) assert len(self.b_channel.bus.bid) == len(self.aw_channel.bus.awid)
@@ -332,10 +332,10 @@ class AxiMasterWrite(Reset):
num_bytes = 2**cmd.size num_bytes = 2**cmd.size
aligned_addr = (cmd.address // num_bytes) * num_bytes aligned_addr = (cmd.address // num_bytes) * num_bytes
word_addr = (cmd.address // self.byte_width) * self.byte_width word_addr = (cmd.address // self.byte_lanes) * self.byte_lanes
start_offset = cmd.address % self.byte_width start_offset = cmd.address % self.byte_lanes
end_offset = ((cmd.address + len(cmd.data) - 1) % self.byte_width) + 1 end_offset = ((cmd.address + len(cmd.data) - 1) % self.byte_lanes) + 1
cycles = (len(cmd.data) + (cmd.address % num_bytes) + num_bytes-1) // num_bytes cycles = (len(cmd.data) + (cmd.address % num_bytes) + num_bytes-1) // num_bytes
@@ -368,7 +368,7 @@ class AxiMasterWrite(Reset):
if k == cycles-1: if k == cycles-1:
stop = end_offset stop = end_offset
strb = (self.strb_mask << start) & self.strb_mask & (self.strb_mask >> (self.byte_width - stop)) strb = (self.strb_mask << start) & self.strb_mask & (self.strb_mask >> (self.byte_lanes - stop))
val = 0 val = 0
for j in range(start, stop): for j in range(start, stop):
@@ -423,7 +423,7 @@ class AxiMasterWrite(Reset):
await self.w_channel.send(w) await self.w_channel.send(w)
cur_addr += num_bytes cur_addr += num_bytes
cycle_offset = (cycle_offset + num_bytes) % self.byte_width cycle_offset = (cycle_offset + num_bytes) % self.byte_lanes
resp_cmd = AxiWriteRespCmd(cmd.address, len(cmd.data), cmd.size, cycles, cmd.prot, burst_list, cmd.event) resp_cmd = AxiWriteRespCmd(cmd.address, len(cmd.data), cmd.size, cycles, cmd.prot, burst_list, cmd.event)
self.tag_context_manager.start_cmd(awid, resp_cmd) self.tag_context_manager.start_cmd(awid, resp_cmd)
@@ -508,21 +508,21 @@ class AxiMasterRead(Reset):
self.width = len(self.r_channel.bus.rdata) self.width = len(self.r_channel.bus.rdata)
self.byte_size = 8 self.byte_size = 8
self.byte_width = self.width // self.byte_size self.byte_lanes = self.width // self.byte_size
self.max_burst_len = max(min(max_burst_len, 256), 1) self.max_burst_len = max(min(max_burst_len, 256), 1)
self.max_burst_size = (self.byte_width-1).bit_length() self.max_burst_size = (self.byte_lanes-1).bit_length()
self.log.info("AXI master configuration:") self.log.info("AXI master configuration:")
self.log.info(" Address width: %d bits", len(self.ar_channel.bus.araddr)) self.log.info(" Address width: %d bits", len(self.ar_channel.bus.araddr))
self.log.info(" ID width: %d bits", len(self.ar_channel.bus.arid)) self.log.info(" ID width: %d bits", len(self.ar_channel.bus.arid))
self.log.info(" Byte size: %d bits", self.byte_size) self.log.info(" Byte size: %d bits", self.byte_size)
self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_width) self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_lanes)
self.log.info(" Max burst size: %d (%d bytes)", self.max_burst_size, 2**self.max_burst_size) self.log.info(" Max burst size: %d (%d bytes)", self.max_burst_size, 2**self.max_burst_size)
self.log.info(" Max burst length: %d cycles (%d bytes)", self.log.info(" Max burst length: %d cycles (%d bytes)",
self.max_burst_len, self.max_burst_len*self.byte_width) self.max_burst_len, self.max_burst_len*self.byte_lanes)
assert self.byte_width * self.byte_size == self.width assert self.byte_lanes * self.byte_size == self.width
assert len(self.r_channel.bus.rid) == len(self.ar_channel.bus.arid) assert len(self.r_channel.bus.rid) == len(self.ar_channel.bus.arid)
@@ -752,9 +752,9 @@ class AxiMasterRead(Reset):
num_bytes = 2**cmd.size num_bytes = 2**cmd.size
aligned_addr = (cmd.address // num_bytes) * num_bytes aligned_addr = (cmd.address // num_bytes) * num_bytes
word_addr = (cmd.address // self.byte_width) * self.byte_width word_addr = (cmd.address // self.byte_lanes) * self.byte_lanes
start_offset = cmd.address % self.byte_width start_offset = cmd.address % self.byte_lanes
cycle_offset = aligned_addr - word_addr cycle_offset = aligned_addr - word_addr
data = bytearray() data = bytearray()
@@ -790,7 +790,7 @@ class AxiMasterRead(Reset):
for j in range(start, stop): for j in range(start, stop):
data.append((cycle_data >> j*8) & 0xff) data.append((cycle_data >> j*8) & 0xff)
cycle_offset = (cycle_offset + num_bytes) % self.byte_width cycle_offset = (cycle_offset + num_bytes) % self.byte_lanes
first = False first = False

30
cocotbext/axi/axi_ram.py
View File

@@ -53,18 +53,18 @@ class AxiRamWrite(Memory, Reset):
self.width = len(self.w_channel.bus.wdata) self.width = len(self.w_channel.bus.wdata)
self.byte_size = 8 self.byte_size = 8
self.byte_width = self.width // self.byte_size self.byte_lanes = self.width // self.byte_size
self.strb_mask = 2**self.byte_width-1 self.strb_mask = 2**self.byte_lanes-1
self.log.info("AXI RAM model configuration:") self.log.info("AXI RAM model configuration:")
self.log.info(" Memory size: %d bytes", len(self.mem)) self.log.info(" Memory size: %d bytes", len(self.mem))
self.log.info(" Address width: %d bits", len(self.aw_channel.bus.awaddr)) self.log.info(" Address width: %d bits", len(self.aw_channel.bus.awaddr))
self.log.info(" ID width: %d bits", len(self.aw_channel.bus.awid)) self.log.info(" ID width: %d bits", len(self.aw_channel.bus.awid))
self.log.info(" Byte size: %d bits", self.byte_size) self.log.info(" Byte size: %d bits", self.byte_size)
self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_width) self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_lanes)
assert self.byte_width == len(self.w_channel.bus.wstrb) assert self.byte_lanes == len(self.w_channel.bus.wstrb)
assert self.byte_width * self.byte_size == self.width assert self.byte_lanes * self.byte_size == self.width
assert len(self.b_channel.bus.bid) == len(self.aw_channel.bus.awid) assert len(self.b_channel.bus.bid) == len(self.aw_channel.bus.awid)
@@ -102,7 +102,7 @@ class AxiRamWrite(Memory, Reset):
awid, addr, length, size, prot) awid, addr, length, size, prot)
num_bytes = 2**size num_bytes = 2**size
assert 0 < num_bytes <= self.byte_width assert 0 < num_bytes <= self.byte_lanes
aligned_addr = (addr // num_bytes) * num_bytes aligned_addr = (addr // num_bytes) * num_bytes
length += 1 length += 1
@@ -120,7 +120,7 @@ class AxiRamWrite(Memory, Reset):
cur_addr = aligned_addr cur_addr = aligned_addr
for n in range(length): for n in range(length):
cur_word_addr = (cur_addr // self.byte_width) * self.byte_width cur_word_addr = (cur_addr // self.byte_lanes) * self.byte_lanes
w = await self.w_channel.recv() w = await self.w_channel.recv()
@@ -132,12 +132,12 @@ class AxiRamWrite(Memory, Reset):
self.mem.seek(cur_word_addr % self.size) self.mem.seek(cur_word_addr % self.size)
data = data.to_bytes(self.byte_width, 'little') data = data.to_bytes(self.byte_lanes, 'little')
self.log.debug("Write word awid: 0x%x addr: 0x%08x wstrb: 0x%02x data: %s", self.log.debug("Write word awid: 0x%x addr: 0x%08x wstrb: 0x%02x data: %s",
awid, cur_addr, strb, ' '.join((f'{c:02x}' for c in data))) awid, cur_addr, strb, ' '.join((f'{c:02x}' for c in data)))
for i in range(self.byte_width): for i in range(self.byte_lanes):
if strb & (1 << i): if strb & (1 << i):
self.mem.write(data[i:i+1]) self.mem.write(data[i:i+1])
else: else:
@@ -177,16 +177,16 @@ class AxiRamRead(Memory, Reset):
self.width = len(self.r_channel.bus.rdata) self.width = len(self.r_channel.bus.rdata)
self.byte_size = 8 self.byte_size = 8
self.byte_width = self.width // self.byte_size self.byte_lanes = self.width // self.byte_size
self.log.info("AXI RAM model configuration:") self.log.info("AXI RAM model configuration:")
self.log.info(" Memory size: %d bytes", len(self.mem)) self.log.info(" Memory size: %d bytes", len(self.mem))
self.log.info(" Address width: %d bits", len(self.ar_channel.bus.araddr)) self.log.info(" Address width: %d bits", len(self.ar_channel.bus.araddr))
self.log.info(" ID width: %d bits", len(self.ar_channel.bus.arid)) self.log.info(" ID width: %d bits", len(self.ar_channel.bus.arid))
self.log.info(" Byte size: %d bits", self.byte_size) self.log.info(" Byte size: %d bits", self.byte_size)
self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_width) self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_lanes)
assert self.byte_width * self.byte_size == self.width assert self.byte_lanes * self.byte_size == self.width
assert len(self.r_channel.bus.rid) == len(self.ar_channel.bus.arid) assert len(self.r_channel.bus.rid) == len(self.ar_channel.bus.arid)
@@ -223,7 +223,7 @@ class AxiRamRead(Memory, Reset):
arid, addr, length, size, prot) arid, addr, length, size, prot)
num_bytes = 2**size num_bytes = 2**size
assert 0 < num_bytes <= self.byte_width assert 0 < num_bytes <= self.byte_lanes
aligned_addr = (addr // num_bytes) * num_bytes aligned_addr = (addr // num_bytes) * num_bytes
length += 1 length += 1
@@ -241,11 +241,11 @@ class AxiRamRead(Memory, Reset):
cur_addr = aligned_addr cur_addr = aligned_addr
for n in range(length): for n in range(length):
cur_word_addr = (cur_addr // self.byte_width) * self.byte_width cur_word_addr = (cur_addr // self.byte_lanes) * self.byte_lanes
self.mem.seek(cur_word_addr % self.size) self.mem.seek(cur_word_addr % self.size)
data = self.mem.read(self.byte_width) data = self.mem.read(self.byte_lanes)
r = self.r_channel._transaction_obj() r = self.r_channel._transaction_obj()
r.rid = arid r.rid = arid

42
cocotbext/axi/axil_master.py
View File

@@ -73,16 +73,16 @@ class AxiLiteMasterWrite(Reset):
self.width = len(self.w_channel.bus.wdata) self.width = len(self.w_channel.bus.wdata)
self.byte_size = 8 self.byte_size = 8
self.byte_width = self.width // self.byte_size self.byte_lanes = self.width // self.byte_size
self.strb_mask = 2**self.byte_width-1 self.strb_mask = 2**self.byte_lanes-1
self.log.info("AXI lite master configuration:") self.log.info("AXI lite master configuration:")
self.log.info(" Address width: %d bits", len(self.aw_channel.bus.awaddr)) self.log.info(" Address width: %d bits", len(self.aw_channel.bus.awaddr))
self.log.info(" Byte size: %d bits", self.byte_size) self.log.info(" Byte size: %d bits", self.byte_size)
self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_width) self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_lanes)
assert self.byte_width == len(self.w_channel.bus.wstrb) assert self.byte_lanes == len(self.w_channel.bus.wstrb)
assert self.byte_width * self.byte_size == self.width assert self.byte_lanes * self.byte_size == self.width
self._process_write_cr = None self._process_write_cr = None
self._process_write_resp_cr = None self._process_write_resp_cr = None
@@ -191,15 +191,15 @@ class AxiLiteMasterWrite(Reset):
cmd = await self.write_command_queue.get() cmd = await self.write_command_queue.get()
self.current_write_command = cmd self.current_write_command = cmd
word_addr = (cmd.address // self.byte_width) * self.byte_width word_addr = (cmd.address // self.byte_lanes) * self.byte_lanes
start_offset = cmd.address % self.byte_width start_offset = cmd.address % self.byte_lanes
end_offset = ((cmd.address + len(cmd.data) - 1) % self.byte_width) + 1 end_offset = ((cmd.address + len(cmd.data) - 1) % self.byte_lanes) + 1
strb_start = (self.strb_mask << start_offset) & self.strb_mask strb_start = (self.strb_mask << start_offset) & self.strb_mask
strb_end = self.strb_mask >> (self.byte_width - end_offset) strb_end = self.strb_mask >> (self.byte_lanes - end_offset)
cycles = (len(cmd.data) + (cmd.address % self.byte_width) + self.byte_width-1) // self.byte_width cycles = (len(cmd.data) + (cmd.address % self.byte_lanes) + self.byte_lanes-1) // self.byte_lanes
resp_cmd = AxiLiteWriteRespCmd(cmd.address, len(cmd.data), cycles, cmd.prot, cmd.event) resp_cmd = AxiLiteWriteRespCmd(cmd.address, len(cmd.data), cycles, cmd.prot, cmd.event)
await self.int_write_resp_command_queue.put(resp_cmd) await self.int_write_resp_command_queue.put(resp_cmd)
@@ -211,7 +211,7 @@ class AxiLiteMasterWrite(Reset):
for k in range(cycles): for k in range(cycles):
start = 0 start = 0
stop = self.byte_width stop = self.byte_lanes
strb = self.strb_mask strb = self.strb_mask
if k == 0: if k == 0:
@@ -227,7 +227,7 @@ class AxiLiteMasterWrite(Reset):
offset += 1 offset += 1
aw = self.aw_channel._transaction_obj() aw = self.aw_channel._transaction_obj()
aw.awaddr = word_addr + k*self.byte_width aw.awaddr = word_addr + k*self.byte_lanes
aw.awprot = cmd.prot aw.awprot = cmd.prot
w = self.w_channel._transaction_obj() w = self.w_channel._transaction_obj()
@@ -295,14 +295,14 @@ class AxiLiteMasterRead(Reset):
self.width = len(self.r_channel.bus.rdata) self.width = len(self.r_channel.bus.rdata)
self.byte_size = 8 self.byte_size = 8
self.byte_width = self.width // self.byte_size self.byte_lanes = self.width // self.byte_size
self.log.info("AXI lite master configuration:") self.log.info("AXI lite master configuration:")
self.log.info(" Address width: %d bits", len(self.ar_channel.bus.araddr)) self.log.info(" Address width: %d bits", len(self.ar_channel.bus.araddr))
self.log.info(" Byte size: %d bits", self.byte_size) self.log.info(" Byte size: %d bits", self.byte_size)
self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_width) self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_lanes)
assert self.byte_width * self.byte_size == self.width assert self.byte_lanes * self.byte_size == self.width
self._process_read_cr = None self._process_read_cr = None
self._process_read_resp_cr = None self._process_read_resp_cr = None
@@ -410,9 +410,9 @@ class AxiLiteMasterRead(Reset):
cmd = await self.read_command_queue.get() cmd = await self.read_command_queue.get()
self.current_read_command = cmd self.current_read_command = cmd
word_addr = (cmd.address // self.byte_width) * self.byte_width word_addr = (cmd.address // self.byte_lanes) * self.byte_lanes
cycles = (cmd.length + self.byte_width-1 + (cmd.address % self.byte_width)) // self.byte_width cycles = (cmd.length + self.byte_lanes-1 + (cmd.address % self.byte_lanes)) // self.byte_lanes
resp_cmd = AxiLiteReadRespCmd(cmd.address, cmd.length, cycles, cmd.prot, cmd.event) resp_cmd = AxiLiteReadRespCmd(cmd.address, cmd.length, cycles, cmd.prot, cmd.event)
await self.int_read_resp_command_queue.put(resp_cmd) await self.int_read_resp_command_queue.put(resp_cmd)
@@ -422,7 +422,7 @@ class AxiLiteMasterRead(Reset):
for k in range(cycles): for k in range(cycles):
ar = self.ar_channel._transaction_obj() ar = self.ar_channel._transaction_obj()
ar.araddr = word_addr + k*self.byte_width ar.araddr = word_addr + k*self.byte_lanes
ar.arprot = cmd.prot ar.arprot = cmd.prot
await self.ar_channel.send(ar) await self.ar_channel.send(ar)
@@ -434,8 +434,8 @@ class AxiLiteMasterRead(Reset):
cmd = await self.int_read_resp_command_queue.get() cmd = await self.int_read_resp_command_queue.get()
self.current_read_resp_command = cmd self.current_read_resp_command = cmd
start_offset = cmd.address % self.byte_width start_offset = cmd.address % self.byte_lanes
end_offset = ((cmd.address + cmd.length - 1) % self.byte_width) + 1 end_offset = ((cmd.address + cmd.length - 1) % self.byte_lanes) + 1
data = bytearray() data = bytearray()
@@ -451,7 +451,7 @@ class AxiLiteMasterRead(Reset):
resp = cycle_resp resp = cycle_resp
start = 0 start = 0
stop = self.byte_width stop = self.byte_lanes
if k == 0: if k == 0:
start = start_offset start = start_offset

26
cocotbext/axi/axil_ram.py
View File

@@ -53,17 +53,17 @@ class AxiLiteRamWrite(Memory, Reset):
self.width = len(self.w_channel.bus.wdata) self.width = len(self.w_channel.bus.wdata)
self.byte_size = 8 self.byte_size = 8
self.byte_width = self.width // self.byte_size self.byte_lanes = self.width // self.byte_size
self.strb_mask = 2**self.byte_width-1 self.strb_mask = 2**self.byte_lanes-1
self.log.info("AXI lite RAM model configuration:") self.log.info("AXI lite RAM model configuration:")
self.log.info(" Memory size: %d bytes", len(self.mem)) self.log.info(" Memory size: %d bytes", len(self.mem))
self.log.info(" Address width: %d bits", len(self.aw_channel.bus.awaddr)) self.log.info(" Address width: %d bits", len(self.aw_channel.bus.awaddr))
self.log.info(" Byte size: %d bits", self.byte_size) self.log.info(" Byte size: %d bits", self.byte_size)
self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_width) self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_lanes)
assert self.byte_width == len(self.w_channel.bus.wstrb) assert self.byte_lanes == len(self.w_channel.bus.wstrb)
assert self.byte_width * self.byte_size == self.width assert self.byte_lanes * self.byte_size == self.width
self._process_write_cr = None self._process_write_cr = None
@@ -88,7 +88,7 @@ class AxiLiteRamWrite(Memory, Reset):
while True: while True:
aw = await self.aw_channel.recv() aw = await self.aw_channel.recv()
addr = (int(aw.awaddr) // self.byte_width) * self.byte_width addr = (int(aw.awaddr) // self.byte_lanes) * self.byte_lanes
prot = AxiProt(aw.awprot) prot = AxiProt(aw.awprot)
w = await self.w_channel.recv() w = await self.w_channel.recv()
@@ -100,12 +100,12 @@ class AxiLiteRamWrite(Memory, Reset):
self.mem.seek(addr % self.size) self.mem.seek(addr % self.size)
data = data.to_bytes(self.byte_width, 'little') data = data.to_bytes(self.byte_lanes, 'little')
self.log.info("Write data awaddr: 0x%08x awprot: %s wstrb: 0x%02x data: %s", self.log.info("Write data awaddr: 0x%08x awprot: %s wstrb: 0x%02x data: %s",
addr, prot, strb, ' '.join((f'{c:02x}' for c in data))) addr, prot, strb, ' '.join((f'{c:02x}' for c in data)))
for i in range(self.byte_width): for i in range(self.byte_lanes):
if strb & (1 << i): if strb & (1 << i):
self.mem.write(data[i:i+1]) self.mem.write(data[i:i+1])
else: else:
@@ -135,15 +135,15 @@ class AxiLiteRamRead(Memory, Reset):
self.width = len(self.r_channel.bus.rdata) self.width = len(self.r_channel.bus.rdata)
self.byte_size = 8 self.byte_size = 8
self.byte_width = self.width // self.byte_size self.byte_lanes = self.width // self.byte_size
self.log.info("AXI lite RAM model configuration:") self.log.info("AXI lite RAM model configuration:")
self.log.info(" Memory size: %d bytes", len(self.mem)) self.log.info(" Memory size: %d bytes", len(self.mem))
self.log.info(" Address width: %d bits", len(self.ar_channel.bus.araddr)) self.log.info(" Address width: %d bits", len(self.ar_channel.bus.araddr))
self.log.info(" Byte size: %d bits", self.byte_size) self.log.info(" Byte size: %d bits", self.byte_size)
self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_width) self.log.info(" Data width: %d bits (%d bytes)", self.width, self.byte_lanes)
assert self.byte_width * self.byte_size == self.width assert self.byte_lanes * self.byte_size == self.width
self._process_read_cr = None self._process_read_cr = None
@@ -167,14 +167,14 @@ class AxiLiteRamRead(Memory, Reset):
while True: while True:
ar = await self.ar_channel.recv() ar = await self.ar_channel.recv()
addr = (int(ar.araddr) // self.byte_width) * self.byte_width addr = (int(ar.araddr) // self.byte_lanes) * self.byte_lanes
prot = AxiProt(ar.arprot) prot = AxiProt(ar.arprot)
# todo latency # todo latency
self.mem.seek(addr % self.size) self.mem.seek(addr % self.size)
data = self.mem.read(self.byte_width) data = self.mem.read(self.byte_lanes)
r = self.r_channel._transaction_obj() r = self.r_channel._transaction_obj()
r.rdata = int.from_bytes(data, 'little') r.rdata = int.from_bytes(data, 'little')

24
tests/axi/test_axi.py
View File

@@ -85,7 +85,7 @@ async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, si
tb = TB(dut) tb = TB(dut)
byte_width = tb.axi_master.write_if.byte_width byte_lanes = tb.axi_master.write_if.byte_lanes
max_burst_size = tb.axi_master.write_if.max_burst_size max_burst_size = tb.axi_master.write_if.max_burst_size
if size is None: if size is None:
@@ -96,8 +96,8 @@ async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, si
tb.set_idle_generator(idle_inserter) tb.set_idle_generator(idle_inserter)
tb.set_backpressure_generator(backpressure_inserter) tb.set_backpressure_generator(backpressure_inserter)
for length in list(range(1, byte_width*2))+[1024]: for length in list(range(1, byte_lanes*2))+[1024]:
for offset in list(range(byte_width))+list(range(4096-byte_width, 4096)): for offset in list(range(byte_lanes))+list(range(4096-byte_lanes, 4096)):
tb.log.info("length %d, offset %d", length, offset) tb.log.info("length %d, offset %d", length, offset)
addr = offset+0x1000 addr = offset+0x1000
test_data = bytearray([x % 256 for x in range(length)]) test_data = bytearray([x % 256 for x in range(length)])
@@ -120,7 +120,7 @@ async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, siz
tb = TB(dut) tb = TB(dut)
byte_width = tb.axi_master.write_if.byte_width byte_lanes = tb.axi_master.write_if.byte_lanes
max_burst_size = tb.axi_master.write_if.max_burst_size max_burst_size = tb.axi_master.write_if.max_burst_size
if size is None: if size is None:
@@ -131,8 +131,8 @@ async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, siz
tb.set_idle_generator(idle_inserter) tb.set_idle_generator(idle_inserter)
tb.set_backpressure_generator(backpressure_inserter) tb.set_backpressure_generator(backpressure_inserter)
for length in list(range(1, byte_width*2))+[1024]: for length in list(range(1, byte_lanes*2))+[1024]:
for offset in list(range(byte_width))+list(range(4096-byte_width, 4096)): for offset in list(range(byte_lanes))+list(range(4096-byte_lanes, 4096)):
tb.log.info("length %d, offset %d", length, offset) tb.log.info("length %d, offset %d", length, offset)
addr = offset+0x1000 addr = offset+0x1000
test_data = bytearray([x % 256 for x in range(length)]) test_data = bytearray([x % 256 for x in range(length)])
@@ -151,12 +151,12 @@ async def run_test_write_words(dut):
tb = TB(dut) tb = TB(dut)
byte_width = tb.axi_master.write_if.byte_width byte_lanes = tb.axi_master.write_if.byte_lanes
await tb.cycle_reset() await tb.cycle_reset()
for length in list(range(1, 4)): for length in list(range(1, 4)):
for offset in list(range(byte_width)): for offset in list(range(byte_lanes)):
tb.log.info("length %d, offset %d", length, offset) tb.log.info("length %d, offset %d", length, offset)
addr = offset+0x1000 addr = offset+0x1000
@@ -205,12 +205,12 @@ async def run_test_read_words(dut):
tb = TB(dut) tb = TB(dut)
byte_width = tb.axi_master.write_if.byte_width byte_lanes = tb.axi_master.write_if.byte_lanes
await tb.cycle_reset() await tb.cycle_reset()
for length in list(range(1, 4)): for length in list(range(1, 4)):
for offset in list(range(byte_width)): for offset in list(range(byte_lanes)):
tb.log.info("length %d, offset %d", length, offset) tb.log.info("length %d, offset %d", length, offset)
addr = offset+0x1000 addr = offset+0x1000
@@ -299,8 +299,8 @@ def cycle_pause():
if cocotb.SIM_NAME: if cocotb.SIM_NAME:
data_width = len(cocotb.top.axi_wdata) data_width = len(cocotb.top.axi_wdata)
byte_width = data_width // 8 byte_lanes = data_width // 8
max_burst_size = (byte_width-1).bit_length() max_burst_size = (byte_lanes-1).bit_length()
for test in [run_test_write, run_test_read]: for test in [run_test_write, run_test_read]:

20
tests/axil/test_axil.py
View File

@@ -82,15 +82,15 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins
tb = TB(dut) tb = TB(dut)
byte_width = tb.axil_master.write_if.byte_width byte_lanes = tb.axil_master.write_if.byte_lanes
await tb.cycle_reset() await tb.cycle_reset()
tb.set_idle_generator(idle_inserter) tb.set_idle_generator(idle_inserter)
tb.set_backpressure_generator(backpressure_inserter) tb.set_backpressure_generator(backpressure_inserter)
for length in range(1, byte_width*2): for length in range(1, byte_lanes*2):
for offset in range(byte_width): for offset in range(byte_lanes):
tb.log.info("length %d, offset %d", length, offset) tb.log.info("length %d, offset %d", length, offset)
addr = offset+0x1000 addr = offset+0x1000
test_data = bytearray([x % 256 for x in range(length)]) test_data = bytearray([x % 256 for x in range(length)])
@@ -113,15 +113,15 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse
tb = TB(dut) tb = TB(dut)
byte_width = tb.axil_master.write_if.byte_width byte_lanes = tb.axil_master.write_if.byte_lanes
await tb.cycle_reset() await tb.cycle_reset()
tb.set_idle_generator(idle_inserter) tb.set_idle_generator(idle_inserter)
tb.set_backpressure_generator(backpressure_inserter) tb.set_backpressure_generator(backpressure_inserter)
for length in range(1, byte_width*2): for length in range(1, byte_lanes*2):
for offset in range(byte_width): for offset in range(byte_lanes):
tb.log.info("length %d, offset %d", length, offset) tb.log.info("length %d, offset %d", length, offset)
addr = offset+0x1000 addr = offset+0x1000
test_data = bytearray([x % 256 for x in range(length)]) test_data = bytearray([x % 256 for x in range(length)])
@@ -140,12 +140,12 @@ async def run_test_write_words(dut):
tb = TB(dut) tb = TB(dut)
byte_width = tb.axil_master.write_if.byte_width byte_lanes = tb.axil_master.write_if.byte_lanes
await tb.cycle_reset() await tb.cycle_reset()
for length in list(range(1, 4)): for length in list(range(1, 4)):
for offset in list(range(byte_width)): for offset in list(range(byte_lanes)):
tb.log.info("length %d, offset %d", length, offset) tb.log.info("length %d, offset %d", length, offset)
addr = offset+0x1000 addr = offset+0x1000
@@ -194,12 +194,12 @@ async def run_test_read_words(dut):
tb = TB(dut) tb = TB(dut)
byte_width = tb.axil_master.write_if.byte_width byte_lanes = tb.axil_master.write_if.byte_lanes
await tb.cycle_reset() await tb.cycle_reset()
for length in list(range(1, 4)): for length in list(range(1, 4)):
for offset in list(range(byte_width)): for offset in list(range(byte_lanes)):
tb.log.info("length %d, offset %d", length, offset) tb.log.info("length %d, offset %d", length, offset)
addr = offset+0x1000 addr = offset+0x1000