github-mirrors/ibex
1
0
Fork 0
mirror of https://github.com/lowRISC/ibex.git synced 2025-04-23 21:39:13 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Update lowrisc_ip to lowRISC/opentitan@34ba5e45f

Browse source 
Update code from upstream repository
https://github.com/lowRISC/opentitan to revision
34ba5e45f9af7d8ca6c9bdae8bd11eeeeb669d6c

* [dv] Add new ECC code options to mem_bkdr_util (Michael Schaffner)
* [secded_gen] Define and generate inverted ECC enc/dec modules
  (Michael Schaffner)
* [dv] Only run registers through one csr_rw sequence at once (Rupert
  Swarbrick)
* [alert_handler] Minor lint fix (Michael Schaffner)
* [prim_clock_div] Fix minor Verilator lint warning (Michael
  Schaffner)
* [dvsim/lint] Make message reporting more flexible (Michael
  Schaffner)
* [lint] Unify lint parser scripts (Michael Schaffner)
* [rom_cntrl, dv] Test to verify successful rom check (Prajwala
  Puttappa)
* [dv, dv_macros] Enhance `DV_GET_ENUM_PLUSARG` macro (Srikrishna
  Iyer)
* [sram/dv] Fix mem data check (Weicai Yang)
* [prim] Add flop wrapper for sparse fsm (Timothy Chen)
* [flash_ctrl] Make data / metadata memories a single entry (Timothy
  Chen)
* [dv] Teach encrypt/decrypt_sram_data to support OTBN (Rupert
  Swarbrick)

Signed-off-by: Michael Schaffner <msf@google.com>
This commit is contained in:
Michael Schaffner 2021-12-02 11:34:22 -08:00
parent 53b1732b19
commit 4df2221dee
99 changed files with 4611 additions and 1321 deletions
Download patch file Download diff file Expand all files Collapse all files

2
vendor/lowrisc_ip.lock.hjson vendored
View file

@ -9,6 +9,6 @@
upstream:
{
url: https://github.com/lowRISC/opentitan
rev: 3a672eb36aee5942d0912a15d15055b1d21c33d6
rev: 34ba5e45f9af7d8ca6c9bdae8bd11eeeeb669d6c
}
}

35
vendor/lowrisc_ip/dv/sv/dv_lib/dv_base_vseq.sv vendored
View file

@ -187,14 +187,27 @@ class dv_base_vseq #(type RAL_T = dv_base_reg_block,
// arg csr_test_type: what csr test to run {hw_reset, rw, bit_bash, aliasing}
// arg num_test_csrs:instead of testing the entire ral model or passing test chunk info via
// plusarg, provide ability to set a random number of csrs to test from higher level sequence
virtual task run_csr_vseq(string csr_test_type = "",
int num_test_csrs = 0,
bit do_rand_wr_and_reset = 1);
csr_base_seq m_csr_seq;
virtual task run_csr_vseq(string csr_test_type = "",
int num_test_csrs = 0,
bit do_rand_wr_and_reset = 1,
string ral_name = "");
csr_base_seq m_csr_seq;
dv_base_reg_block models[string];
// env needs to have a ral instance
// env needs to have at least one ral instance
`DV_CHECK_GE_FATAL(cfg.ral_models.size(), 1)
// If ral_name is specified, only use registers on that named interface. Otherwise, use all
// registers.
if (ral_name != "") begin
`DV_CHECK_FATAL(cfg.ral_models.exists(ral_name))
models[ral_name] = cfg.ral_models[ral_name];
end else begin
foreach (cfg.ral_models[i]) begin
models[i] = cfg.ral_models[i];
end
end
// check which csr test type
case (csr_test_type)
"hw_reset": csr_base_seq::type_id::set_type_override(csr_hw_reset_seq::get_type());
@ -206,8 +219,8 @@ class dv_base_vseq #(type RAL_T = dv_base_reg_block,
endcase
// Print the list of available exclusions that are in effect for debug.
foreach (cfg.ral_models[i]) begin
csr_excl_item csr_excl = csr_utils_pkg::get_excl_item(cfg.ral_models[i]);
foreach (models[i]) begin
csr_excl_item csr_excl = csr_utils_pkg::get_excl_item(models[i]);
if (csr_excl != null) csr_excl.print_exclusions();
end
@ -227,8 +240,8 @@ class dv_base_vseq #(type RAL_T = dv_base_reg_block,
m_csr_write_seq = csr_write_seq::type_id::create("m_csr_write_seq");
// We have to assign this array in a loop because the element types aren't equivalent, so
// the array types aren't assignment compatible.
foreach (cfg.ral_models[i]) begin
m_csr_write_seq.models[i] = cfg.ral_models[i];
foreach (models[i]) begin
m_csr_write_seq.models[i] = models[i];
end
m_csr_write_seq.external_checker = cfg.en_scb;
m_csr_write_seq.en_rand_backdoor_write = 1'b1;
@ -248,8 +261,8 @@ class dv_base_vseq #(type RAL_T = dv_base_reg_block,
m_csr_seq = csr_base_seq::type_id::create("m_csr_seq");
// We have to assign this array in a loop because the element types aren't equivalent, so
// the array types aren't assignment compatible.
foreach (cfg.ral_models[i]) begin
m_csr_seq.models[i] = cfg.ral_models[i];
foreach (models[i]) begin
m_csr_seq.models[i] = models[i];
end
m_csr_seq.external_checker = cfg.en_scb;
m_csr_seq.num_test_csrs = num_test_csrs;

23
vendor/lowrisc_ip/dv/sv/dv_utils/dv_macros.svh vendored
View file

@ -413,20 +413,25 @@
end
`endif
// This macro converts a string input from plusarg to an enum variable
// ENUM_: the name of enum type
// PLUSARG_: the name of the plusargs, which is also the name of the enum variable
// CHECK_EXIST_: set to 1, `$value$plusargs()` should return true
// Retrieves a plusarg value representing an enum literal.
//
// The plusarg is parsed as a string, which needs to be converted into the enum literal whose name
// matches the string. This functionality is provided by the UVM helper function below.
//
// ENUM_: The enum type.
// VAR_: The enum variable to which the plusarg value will be set (must be declared already).
// PLUSARG_: the name of the plusarg (as raw text). This is typically the same as the enum variable.
// CHECK_EXISTS_: Throws a fatal error if the plusarg is not set.
`ifndef DV_GET_ENUM_PLUSARG
`define DV_GET_ENUM_PLUSARG(ENUM_, PLUSARG_, CHECK_EXIST_ = 0, ID_ = `gfn) \
`define DV_GET_ENUM_PLUSARG(ENUM_, VAR_, PLUSARG_ = VAR_, CHECK_EXISTS_ = 0, ID_ = `gfn) \
begin \
string str; \
if ($value$plusargs("``PLUSARG_``=%0s", str)) begin \
if (!uvm_enum_wrapper#(ENUM_)::from_name(str, PLUSARG_)) begin \
`uvm_fatal(ID_, $sformatf("Cannot find %s from enum ``ENUM_``", PLUSARG_.name)) \
if (!uvm_enum_wrapper#(ENUM_)::from_name(str, VAR_)) begin \
`uvm_fatal(ID_, $sformatf("Cannot find %s from enum ``ENUM_``", VAR_.name())) \
end \
end else if (CHECK_EXIST_) begin \
`uvm_fatal(ID_, "Can't find plusargs ``PLUSARG_``") \
end else if (CHECK_EXISTS_) begin \
`uvm_fatal(ID_, "Please pass the plusarg +``PLUSARG_``=<``ENUM_``-literal>") \
end \
end
`endif

39
vendor/lowrisc_ip/dv/sv/mem_bkdr_util/mem_bkdr_util.sv vendored
View file

@ -313,6 +313,27 @@ class mem_bkdr_util extends uvm_object;
EccHamming_76_68: begin
rw_data = prim_secded_pkg::prim_secded_hamming_76_68_enc(rw_data[63:0]);
end
EccInv_22_16: begin
rw_data = prim_secded_pkg::prim_secded_inv_22_16_enc(rw_data[15:0]);
end
EccInvHamming_22_16: begin
rw_data = prim_secded_pkg::prim_secded_inv_hamming_22_16_enc(rw_data[15:0]);
end
EccInv_39_32: begin
rw_data = prim_secded_pkg::prim_secded_inv_39_32_enc(rw_data[31:0]);
end
EccInvHamming_39_32: begin
rw_data = prim_secded_pkg::prim_secded_inv_hamming_39_32_enc(rw_data[31:0]);
end
EccInv_72_64: begin
rw_data = prim_secded_pkg::prim_secded_inv_72_64_enc(rw_data[63:0]);
end
EccInvHamming_72_64: begin
rw_data = prim_secded_pkg::prim_secded_inv_hamming_72_64_enc(rw_data[63:0]);
end
EccInvHamming_76_68: begin
rw_data = prim_secded_pkg::prim_secded_inv_hamming_76_68_enc(rw_data[63:0]);
end
default: begin
`uvm_error(`gfn, $sformatf("ECC scheme %0s is unsupported.", err_detection_scheme))
end
@ -383,6 +404,12 @@ class mem_bkdr_util extends uvm_object;
EccHamming_22_16: begin
return prim_secded_pkg::prim_secded_hamming_22_16_dec(data);
end
EccInv_22_16: begin
return prim_secded_pkg::prim_secded_inv_22_16_dec(data);
end
EccInvHamming_22_16: begin
return prim_secded_pkg::prim_secded_inv_hamming_22_16_dec(data);
end
default: return 'x;
endcase
endfunction
@ -399,6 +426,12 @@ class mem_bkdr_util extends uvm_object;
EccHamming_39_32: begin
return prim_secded_pkg::prim_secded_hamming_39_32_dec(data);
end
EccInv_39_32: begin
return prim_secded_pkg::prim_secded_inv_39_32_dec(data);
end
EccInvHamming_39_32: begin
return prim_secded_pkg::prim_secded_inv_hamming_39_32_dec(data);
end
default: return 'x;
endcase
endfunction
@ -415,6 +448,12 @@ class mem_bkdr_util extends uvm_object;
EccHamming_72_64: begin
return prim_secded_pkg::prim_secded_hamming_72_64_dec(data);
end
EccInv_72_64: begin
return prim_secded_pkg::prim_secded_inv_72_64_dec(data);
end
EccInvHamming_72_64: begin
return prim_secded_pkg::prim_secded_inv_hamming_72_64_dec(data);
end
default: return 'x;
endcase
endfunction

54
vendor/lowrisc_ip/dv/sv/mem_bkdr_util/mem_bkdr_util__rom.sv vendored
View file

@ -66,3 +66,57 @@ virtual function bit [38:0] rom_encrypt_read32(bit [bus_params_pkg::BUS_AW-1:0]
return data;
endfunction
virtual function void rom_encrypt_write32_integ(logic [bus_params_pkg::BUS_AW-1:0] addr,
logic [31:0] data,
logic [SRAM_KEY_WIDTH-1:0] key,
logic [SRAM_BLOCK_WIDTH-1:0] nonce,
bit scramble_data);
logic [bus_params_pkg::BUS_AW-1:0] bus_addr = '0;
logic [38:0] integ_data;
logic [38:0] scrambled_data;
logic wdata_arr [] = new[39];
logic scrambled_addr [] = new[addr_width];
logic rom_addr [] = new[addr_width];
logic key_arr [] = new[SRAM_KEY_WIDTH];
logic nonce_arr [] = new[SRAM_BLOCK_WIDTH];
key_arr = {<<{key}};
nonce_arr = {<<{nonce}};
for (int i = 0; i < addr_width; i++) begin
rom_addr[i] = addr[addr_lsb + i];
end
// Calculate the scrambled address
scrambled_addr = sram_scrambler_pkg::encrypt_sram_addr(rom_addr, addr_width, nonce_arr);
if(scramble_data) begin
// Calculate the integrity constant
integ_data = prim_secded_pkg::prim_secded_39_32_enc(data);
// Calculate the scrambled data
wdata_arr = {<<{integ_data}};
wdata_arr = sram_scrambler_pkg::encrypt_sram_data(
wdata_arr, 39, 0, rom_addr, addr_width, key_arr, nonce_arr
);
scrambled_data = {<<{wdata_arr}};
end
else begin
scrambled_data = data;
end
// Construct bus representation of the address
for (int i = 0; i < addr_lsb; i++) begin
bus_addr[i] = addr[i];
end
for (int i = 0; i < addr_width; i++) begin
bus_addr[addr_lsb + i] = scrambled_addr[i];
end
// Write the scrambled data to memory
write39integ(bus_addr, scrambled_data);
endfunction

22
vendor/lowrisc_ip/dv/sv/mem_bkdr_util/mem_bkdr_util__sram.sv vendored
View file

@ -39,7 +39,7 @@ virtual function logic [7:0] sram_encrypt_read8(logic [bus_params_pkg::BUS_AW-1:
rdata = read8(bus_addr);
rdata_arr = {<<{rdata}};
rdata_arr = sram_scrambler_pkg::decrypt_sram_data(
rdata_arr, 8, 1, sram_addr, addr_width, key_arr, nonce_arr
rdata_arr, 8, 8, sram_addr, addr_width, key_arr, nonce_arr
);
rdata = {<<{rdata_arr}};
return rdata;
@ -79,7 +79,7 @@ virtual function logic [15:0] sram_encrypt_read16(logic [bus_params_pkg::BUS_AW-
rdata = read16(bus_addr);
rdata_arr = {<<{rdata}};
rdata_arr = sram_scrambler_pkg::decrypt_sram_data(
rdata_arr, 16, 1, sram_addr, addr_width, key_arr, nonce_arr
rdata_arr, 16, 8, sram_addr, addr_width, key_arr, nonce_arr
);
rdata = {<<{rdata_arr}};
return rdata;
@ -118,7 +118,7 @@ virtual function logic [31:0] sram_encrypt_read32(logic [bus_params_pkg::BUS_AW-
rdata = read32(bus_addr);
rdata_arr = {<<{rdata}};
rdata_arr = sram_scrambler_pkg::decrypt_sram_data(
rdata_arr, 32, 1, sram_addr, addr_width, key_arr, nonce_arr
rdata_arr, 32, 8, sram_addr, addr_width, key_arr, nonce_arr
);
rdata = {<<{rdata_arr}};
return rdata;
@ -159,7 +159,7 @@ virtual function logic [38:0] sram_encrypt_read32_integ(logic [bus_params_pkg::B
`uvm_info(`gfn, $sformatf("scr data: 0x%0x", rdata), UVM_HIGH)
rdata_arr = {<<{rdata}};
rdata_arr = sram_scrambler_pkg::decrypt_sram_data(
rdata_arr, 39, 0, sram_addr, addr_width, key_arr, nonce_arr
rdata_arr, 39, 39, sram_addr, addr_width, key_arr, nonce_arr
);
rdata = {<<{rdata_arr}};
// Only return the data payload without ECC bits.
@ -201,7 +201,7 @@ virtual function logic [63:0] sram_encrypt_read64(logic [bus_params_pkg::BUS_AW-
rdata = read64(bus_addr);
rdata_arr = {<<{rdata}};
rdata_arr = sram_scrambler_pkg::decrypt_sram_data(
rdata_arr, 64, 1, sram_addr, addr_width, key_arr, nonce_arr
rdata_arr, 64, 8, sram_addr, addr_width, key_arr, nonce_arr
);
rdata = {<<{rdata_arr}};
return rdata;
@ -234,7 +234,7 @@ virtual function void sram_encrypt_write8(logic [bus_params_pkg::BUS_AW-1:0] add
// Calculate the scrambled data
wdata_arr = {<<{data}};
wdata_arr = sram_scrambler_pkg::encrypt_sram_data(
wdata_arr, 8, 1, sram_addr, addr_width, key_arr, nonce_arr
wdata_arr, 8, 8, sram_addr, addr_width, key_arr, nonce_arr
);
scrambled_data = {<<{wdata_arr}};
@ -276,7 +276,7 @@ virtual function void sram_encrypt_write16(logic [bus_params_pkg::BUS_AW-1:0] ad
// Calculate the scrambled data
wdata_arr = {<<{data}};
wdata_arr = sram_scrambler_pkg::encrypt_sram_data(
wdata_arr, 16, 1, sram_addr, addr_width, key_arr, nonce_arr
wdata_arr, 16, 8, sram_addr, addr_width, key_arr, nonce_arr
);
scrambled_data = {<<{wdata_arr}};
@ -318,7 +318,7 @@ virtual function void sram_encrypt_write32(logic [bus_params_pkg::BUS_AW-1:0] ad
// Calculate the scrambled data
wdata_arr = {<<{data}};
wdata_arr = sram_scrambler_pkg::encrypt_sram_data(
wdata_arr, 32, 1, sram_addr, addr_width, key_arr, nonce_arr
wdata_arr, 32, 8, sram_addr, addr_width, key_arr, nonce_arr
);
scrambled_data = {<<{wdata_arr}};
@ -359,12 +359,12 @@ virtual function void sram_encrypt_write32_integ(logic [bus_params_pkg::BUS_AW-1
scrambled_addr = sram_scrambler_pkg::encrypt_sram_addr(sram_addr, addr_width, nonce_arr);
// Calculate the integrity constant
integ_data = prim_secded_pkg::prim_secded_39_32_enc(data);
integ_data = prim_secded_pkg::prim_secded_inv_39_32_enc(data);
// Calculate the scrambled data
wdata_arr = {<<{integ_data}};
wdata_arr = sram_scrambler_pkg::encrypt_sram_data(
wdata_arr, 39, 0, sram_addr, addr_width, key_arr, nonce_arr
wdata_arr, 39, 39, sram_addr, addr_width, key_arr, nonce_arr
);
scrambled_data = {<<{wdata_arr}};
@ -406,7 +406,7 @@ virtual function void sram_encrypt_write64(logic [bus_params_pkg::BUS_AW-1:0] ad
// Calculate the scrambled data
wdata_arr = {<<{data}};
wdata_arr = sram_scrambler_pkg::encrypt_sram_data(
wdata_arr, 64, 1, sram_addr, addr_width, key_arr, nonce_arr
wdata_arr, 64, 8, sram_addr, addr_width, key_arr, nonce_arr
);
scrambled_data = {<<{wdata_arr}};

9
vendor/lowrisc_ip/dv/sv/mem_bkdr_util/mem_bkdr_util_pkg.sv vendored
View file

@ -26,6 +26,15 @@ package mem_bkdr_util_pkg;
EccHamming_39_32 = prim_secded_pkg::SecdedHamming_39_32,
EccHamming_72_64 = prim_secded_pkg::SecdedHamming_72_64,
EccHamming_76_68 = prim_secded_pkg::SecdedHamming_76_68,
EccInv_22_16 = prim_secded_pkg::SecdedInv_22_16,
EccInv_28_22 = prim_secded_pkg::SecdedInv_28_22,
EccInv_39_32 = prim_secded_pkg::SecdedInv_39_32,
EccInv_64_57 = prim_secded_pkg::SecdedInv_64_57,
EccInv_72_64 = prim_secded_pkg::SecdedInv_72_64,
EccInvHamming_22_16 = prim_secded_pkg::SecdedInvHamming_22_16,
EccInvHamming_39_32 = prim_secded_pkg::SecdedInvHamming_39_32,
EccInvHamming_72_64 = prim_secded_pkg::SecdedInvHamming_72_64,
EccInvHamming_76_68 = prim_secded_pkg::SecdedInvHamming_76_68,
ParityEven,
ParityOdd
} err_detection_e;

65
vendor/lowrisc_ip/dv/sv/mem_bkdr_util/sram_scrambler_pkg.sv vendored
View file

@ -216,17 +216,15 @@ package sram_scrambler_pkg;
// and then XOR the result with the data.
//
// After that, the XORed data neeeds to them be passed through the S&P network one byte at a time.
//
// TODO: We currently do not support data size of >64bits.
function automatic state_t encrypt_sram_data(logic data[], int data_width, bit byte_diff,
function automatic state_t encrypt_sram_data(logic data[], int data_width, int sp_width,
logic addr[], int addr_width,
logic key[], logic nonce[]);
// Generate the keystream
logic keystream[] = new[SRAM_BLOCK_WIDTH];
logic data_enc[] = new[data_width];
logic byte_to_enc[] = new[8];
logic enc_byte[] = new[8];
logic zero_key[] = new[data_width];
int ks_width = (data_width < 64) ? data_width : 64;
// the key used for byte diffusion is all-zero.
for (int i = 0; i < data_width; i++) begin
@ -237,27 +235,44 @@ package sram_scrambler_pkg;
keystream = gen_keystream(addr, addr_width, key, nonce);
// XOR keystream with input data
// Assumes data width <= 64.
// Assumes ks_width <= 64.
for (int i = 0; i < data_width; i++) begin
data_enc[i] = data[i] ^ keystream[i];
data_enc[i] = data[i] ^ keystream[i % ks_width];
end
// pass each byte of the encoded result through the subst/perm network
if (byte_diff) begin
if (data_width == sp_width) begin
// pass the entire word through the subst/perm network at once (the next cases would give the
// same results too, but this should be a bit more efficient)
data_enc = sp_encrypt(data_enc, data_width, zero_key);
end else if (sp_width == 8) begin
// pass each byte of the encoded result through the subst/perm network (special case of the
// general code below)
for (int i = 0; i < data_width / 8; i++) begin
byte_to_enc = data_enc[i*8 +: 8];
enc_byte = sp_encrypt(byte_to_enc, 8, zero_key);
data_enc[i*8 +: 8] = enc_byte;
end
// pass the entire word through the subst/perm network
end else begin
data_enc = sp_encrypt(data_enc, data_width, zero_key);
// divide the word into sp_width chunks to pass it through the subst/perm network
for (int chunk_lsb = 0; chunk_lsb < data_width; chunk_lsb += sp_width) begin
int bits_remaining = data_width - chunk_lsb;
int chunk_width = (bits_remaining < sp_width) ? bits_remaining : sp_width;
logic chunk[] = new[chunk_width];
for (int j = 0; j < chunk_width; j++) begin
chunk[j] = data_enc[chunk_lsb + j];
end
chunk = sp_encrypt(chunk, chunk_width, zero_key);
for (int j = 0; j < chunk_width; j++) begin
data_enc[chunk_lsb + j] = chunk[j];
end
end
end
return data_enc;
endfunction : encrypt_sram_data
function automatic state_t decrypt_sram_data(logic data[], int data_width, bit byte_diff,
function automatic state_t decrypt_sram_data(logic data[], int data_width, int sp_width,
logic addr[], int addr_width,
logic key[], logic nonce[]);
logic keystream[] = new[SRAM_BLOCK_WIDTH];
@ -265,6 +280,7 @@ package sram_scrambler_pkg;
logic byte_to_dec[] = new[8];
logic dec_byte[] = new[8];
logic zero_key[] = new[data_width];
int ks_width = (data_width < 64) ? data_width : 64;
// the key used for byte diffusion is all-zero.
for (int i = 0; i < data_width; i++) begin
@ -274,21 +290,38 @@ package sram_scrambler_pkg;
// Generate the keystream
keystream = gen_keystream(addr, addr_width, key, nonce);
// pass each byte of the data through the subst/perm network
if (byte_diff) begin
if (data_width == sp_width) begin
// pass the entire word through the subst/perm network at once (the next cases would give the
// same results too, but this should be a bit more efficient)
data_dec = sp_decrypt(data, data_width, zero_key);
end else if (sp_width == 8) begin
// pass each byte of the data through the subst/perm network (special case of the general code
// below)
for (int i = 0; i < data_width / 8; i++) begin
byte_to_dec = data[i*8 +: 8];
dec_byte = sp_decrypt(byte_to_dec, 8, zero_key);
data_dec[i*8 +: 8] = dec_byte;
end
// pass the entire word through the subst/perm network
end else begin
data_dec = sp_decrypt(data, data_width, zero_key);
// divide the word into sp_width chunks to pass it through the subst/perm network
for (int chunk_lsb = 0; chunk_lsb < data_width; chunk_lsb += sp_width) begin
int bits_remaining = data_width - chunk_lsb;
int chunk_width = (bits_remaining < sp_width) ? bits_remaining : sp_width;
logic chunk[] = new[chunk_width];
for (int j = 0; j < chunk_width; j++) begin
chunk[j] = data[chunk_lsb + j];
end
chunk = sp_decrypt(chunk, chunk_width, zero_key);
for (int j = 0; j < chunk_width; j++) begin
data_dec[chunk_lsb + j] = chunk[j];
end
end
end
// XOR result data with the keystream
for (int i = 0; i < data_width; i++) begin
data_dec[i] = data_dec[i] ^ keystream[i];
data_dec[i] = data_dec[i] ^ keystream[i % ks_width];
end
return data_dec;

17
vendor/lowrisc_ip/dv/sv/mem_model/mem_model.sv vendored
View file

@ -16,6 +16,10 @@ class mem_model #(int AddrWidth = bus_params_pkg::BUS_AW,
`uvm_object_new
function void init();
system_memory.delete();
endfunction
function int get_written_bytes();
return system_memory.size();
endfunction
@ -33,14 +37,13 @@ class mem_model #(int AddrWidth = bus_params_pkg::BUS_AW,
endfunction
function void write_byte(mem_addr_t addr, bit [7:0] data);
`uvm_info(`gfn, $sformatf("Write Mem : Addr[0x%0h], Data[0x%0h]", addr, data), UVM_HIGH)
`uvm_info(`gfn, $sformatf("Write Mem : Addr[0x%0h], Data[0x%0h]", addr, data), UVM_MEDIUM)
system_memory[addr] = data;
endfunction
function void compare_byte(mem_addr_t addr, bit [7:0] act_data);
`uvm_info(`gfn, $sformatf("Compare Mem : Addr[0x%0h], Act Data[0x%0h], Exp Data[0x%0h]",
addr, act_data, system_memory[addr]), UVM_HIGH)
system_memory[addr] = act_data;
addr, act_data, system_memory[addr]), UVM_MEDIUM)
`DV_CHECK_EQ(act_data, system_memory[addr], $sformatf("addr 0x%0h read out mismatch", addr))
endfunction
@ -67,12 +70,14 @@ class mem_model #(int AddrWidth = bus_params_pkg::BUS_AW,
return data;
endfunction
function void compare(mem_addr_t addr, mem_data_t act_data, mem_mask_t mask = '1);
function void compare(mem_addr_t addr, mem_data_t act_data, mem_mask_t mask = '1,
bit compare_exist_addr_only = 1);
bit [7:0] byte_data;
for (int i = 0; i < DataWidth / 8; i++) begin
mem_addr_t byte_addr = addr + i;
byte_data = act_data[7:0];
if (mask[0]) begin
compare_byte(addr + i, byte_data);
if (mask[0] && (!compare_exist_addr_only || system_memory.exists(byte_addr))) begin
compare_byte(byte_addr, byte_data);
end else begin
// Nothing to do here: since this byte wasn't selected by the mask, there are no
// requirements about what data came back.

140
vendor/lowrisc_ip/ip/prim/dv/prim_secded/secded_enc.c vendored
View file

@ -5,13 +5,13 @@
// SECDED encode code generated by
// util/design/secded_gen.py from util/design/data/secded_cfg.hjson
#include "secded_enc.h"
#include <stdbool.h>
#include <stdint.h>
#include "secded_enc.h"
// Calculates even parity for a 64-bit word
static uint8_t calc_parity(uint64_t word) {
static uint8_t calc_parity(uint64_t word, bool invert) {
bool parity = false;
while (word) {
@ -22,40 +22,43 @@ static uint8_t calc_parity(uint64_t word) {
word >>= 1;
}
return parity;
return parity ^ invert;
}
uint8_t enc_secded_22_16(const uint8_t bytes[2]) {
uint16_t word = ((uint16_t)bytes[0] << 0) | ((uint16_t)bytes[1] << 8);
return (calc_parity(word & 0x496e) << 0) | (calc_parity(word & 0xf20b) << 1) |
(calc_parity(word & 0x8ed8) << 2) | (calc_parity(word & 0x7714) << 3) |
(calc_parity(word & 0xaca5) << 4) | (calc_parity(word & 0x11f3) << 5);
return (calc_parity(word & 0x496e, false) << 0) |
(calc_parity(word & 0xf20b, false) << 1) |
(calc_parity(word & 0x8ed8, false) << 2) |
(calc_parity(word & 0x7714, false) << 3) |
(calc_parity(word & 0xaca5, false) << 4) |
(calc_parity(word & 0x11f3, false) << 5);
}
uint8_t enc_secded_28_22(const uint8_t bytes[3]) {
uint32_t word = ((uint32_t)bytes[0] << 0) | ((uint32_t)bytes[1] << 8) |
((uint32_t)bytes[2] << 16);
return (calc_parity(word & 0x3003ff) << 0) |
(calc_parity(word & 0x10fc0f) << 1) |
(calc_parity(word & 0x271c71) << 2) |
(calc_parity(word & 0x3b6592) << 3) |
(calc_parity(word & 0x3daaa4) << 4) |
(calc_parity(word & 0x3ed348) << 5);
return (calc_parity(word & 0x3003ff, false) << 0) |
(calc_parity(word & 0x10fc0f, false) << 1) |
(calc_parity(word & 0x271c71, false) << 2) |
(calc_parity(word & 0x3b6592, false) << 3) |
(calc_parity(word & 0x3daaa4, false) << 4) |
(calc_parity(word & 0x3ed348, false) << 5);
}
uint8_t enc_secded_39_32(const uint8_t bytes[4]) {
uint32_t word = ((uint32_t)bytes[0] << 0) | ((uint32_t)bytes[1] << 8) |
((uint32_t)bytes[2] << 16) | ((uint32_t)bytes[3] << 24);
return (calc_parity(word & 0x2606bd25) << 0) |
(calc_parity(word & 0xdeba8050) << 1) |
(calc_parity(word & 0x413d89aa) << 2) |
(calc_parity(word & 0x31234ed1) << 3) |
(calc_parity(word & 0xc2c1323b) << 4) |
(calc_parity(word & 0x2dcc624c) << 5) |
(calc_parity(word & 0x98505586) << 6);
return (calc_parity(word & 0x2606bd25, false) << 0) |
(calc_parity(word & 0xdeba8050, false) << 1) |
(calc_parity(word & 0x413d89aa, false) << 2) |
(calc_parity(word & 0x31234ed1, false) << 3) |
(calc_parity(word & 0xc2c1323b, false) << 4) |
(calc_parity(word & 0x2dcc624c, false) << 5) |
(calc_parity(word & 0x98505586, false) << 6);
}
uint8_t enc_secded_64_57(const uint8_t bytes[8]) {
@ -64,13 +67,13 @@ uint8_t enc_secded_64_57(const uint8_t bytes[8]) {
((uint64_t)bytes[4] << 32) | ((uint64_t)bytes[5] << 40) |
((uint64_t)bytes[6] << 48) | ((uint64_t)bytes[7] << 56);
return (calc_parity(word & 0x103fff800007fff) << 0) |
(calc_parity(word & 0x17c1ff801ff801f) << 1) |
(calc_parity(word & 0x1bde1f87e0781e1) << 2) |
(calc_parity(word & 0x1deee3b8e388e22) << 3) |
(calc_parity(word & 0x1ef76cdb2c93244) << 4) |
(calc_parity(word & 0x1f7bb56d5525488) << 5) |
(calc_parity(word & 0x1fbdda769a46910) << 6);
return (calc_parity(word & 0x103fff800007fff, false) << 0) |
(calc_parity(word & 0x17c1ff801ff801f, false) << 1) |
(calc_parity(word & 0x1bde1f87e0781e1, false) << 2) |
(calc_parity(word & 0x1deee3b8e388e22, false) << 3) |
(calc_parity(word & 0x1ef76cdb2c93244, false) << 4) |
(calc_parity(word & 0x1f7bb56d5525488, false) << 5) |
(calc_parity(word & 0x1fbdda769a46910, false) << 6);
}
uint8_t enc_secded_72_64(const uint8_t bytes[8]) {
@ -79,12 +82,79 @@ uint8_t enc_secded_72_64(const uint8_t bytes[8]) {
((uint64_t)bytes[4] << 32) | ((uint64_t)bytes[5] << 40) |
((uint64_t)bytes[6] << 48) | ((uint64_t)bytes[7] << 56);
return (calc_parity(word & 0xb9000000001fffff) << 0) |
(calc_parity(word & 0x5e00000fffe0003f) << 1) |
(calc_parity(word & 0x67003ff003e007c1) << 2) |
(calc_parity(word & 0xcd0fc0f03c207842) << 3) |
(calc_parity(word & 0xb671c711c4438884) << 4) |
(calc_parity(word & 0xb5b65926488c9108) << 5) |
(calc_parity(word & 0xcbdaaa4a91152210) << 6) |
(calc_parity(word & 0x7aed348d221a4420) << 7);
return (calc_parity(word & 0xb9000000001fffff, false) << 0) |
(calc_parity(word & 0x5e00000fffe0003f, false) << 1) |
(calc_parity(word & 0x67003ff003e007c1, false) << 2) |
(calc_parity(word & 0xcd0fc0f03c207842, false) << 3) |
(calc_parity(word & 0xb671c711c4438884, false) << 4) |
(calc_parity(word & 0xb5b65926488c9108, false) << 5) |
(calc_parity(word & 0xcbdaaa4a91152210, false) << 6) |
(calc_parity(word & 0x7aed348d221a4420, false) << 7);
}
uint8_t enc_secded_inv_22_16(const uint8_t bytes[2]) {
uint16_t word = ((uint16_t)bytes[0] << 0) | ((uint16_t)bytes[1] << 8);
return (calc_parity(word & 0x496e, true) << 0) |
(calc_parity(word & 0xf20b, true) << 1) |
(calc_parity(word & 0x8ed8, true) << 2) |
(calc_parity(word & 0x7714, true) << 3) |
(calc_parity(word & 0xaca5, true) << 4) |
(calc_parity(word & 0x11f3, true) << 5);
}
uint8_t enc_secded_inv_28_22(const uint8_t bytes[3]) {
uint32_t word = ((uint32_t)bytes[0] << 0) | ((uint32_t)bytes[1] << 8) |
((uint32_t)bytes[2] << 16);
return (calc_parity(word & 0x3003ff, true) << 0) |
(calc_parity(word & 0x10fc0f, true) << 1) |
(calc_parity(word & 0x271c71, true) << 2) |
(calc_parity(word & 0x3b6592, true) << 3) |
(calc_parity(word & 0x3daaa4, true) << 4) |
(calc_parity(word & 0x3ed348, true) << 5);
}
uint8_t enc_secded_inv_39_32(const uint8_t bytes[4]) {
uint32_t word = ((uint32_t)bytes[0] << 0) | ((uint32_t)bytes[1] << 8) |
((uint32_t)bytes[2] << 16) | ((uint32_t)bytes[3] << 24);
return (calc_parity(word & 0x2606bd25, true) << 0) |
(calc_parity(word & 0xdeba8050, true) << 1) |
(calc_parity(word & 0x413d89aa, true) << 2) |
(calc_parity(word & 0x31234ed1, true) << 3) |
(calc_parity(word & 0xc2c1323b, true) << 4) |
(calc_parity(word & 0x2dcc624c, true) << 5) |
(calc_parity(word & 0x98505586, true) << 6);
}
uint8_t enc_secded_inv_64_57(const uint8_t bytes[8]) {
uint64_t word = ((uint64_t)bytes[0] << 0) | ((uint64_t)bytes[1] << 8) |
((uint64_t)bytes[2] << 16) | ((uint64_t)bytes[3] << 24) |
((uint64_t)bytes[4] << 32) | ((uint64_t)bytes[5] << 40) |
((uint64_t)bytes[6] << 48) | ((uint64_t)bytes[7] << 56);
return (calc_parity(word & 0x103fff800007fff, true) << 0) |
(calc_parity(word & 0x17c1ff801ff801f, true) << 1) |
(calc_parity(word & 0x1bde1f87e0781e1, true) << 2) |
(calc_parity(word & 0x1deee3b8e388e22, true) << 3) |
(calc_parity(word & 0x1ef76cdb2c93244, true) << 4) |
(calc_parity(word & 0x1f7bb56d5525488, true) << 5) |
(calc_parity(word & 0x1fbdda769a46910, true) << 6);
}
uint8_t enc_secded_inv_72_64(const uint8_t bytes[8]) {
uint64_t word = ((uint64_t)bytes[0] << 0) | ((uint64_t)bytes[1] << 8) |
((uint64_t)bytes[2] << 16) | ((uint64_t)bytes[3] << 24) |
((uint64_t)bytes[4] << 32) | ((uint64_t)bytes[5] << 40) |
((uint64_t)bytes[6] << 48) | ((uint64_t)bytes[7] << 56);
return (calc_parity(word & 0xb9000000001fffff, true) << 0) |
(calc_parity(word & 0x5e00000fffe0003f, true) << 1) |
(calc_parity(word & 0x67003ff003e007c1, true) << 2) |
(calc_parity(word & 0xcd0fc0f03c207842, true) << 3) |
(calc_parity(word & 0xb671c711c4438884, true) << 4) |
(calc_parity(word & 0xb5b65926488c9108, true) << 5) |
(calc_parity(word & 0xcbdaaa4a91152210, true) << 6) |
(calc_parity(word & 0x7aed348d221a4420, true) << 7);
}

5
vendor/lowrisc_ip/ip/prim/dv/prim_secded/secded_enc.h vendored
View file

@ -23,6 +23,11 @@ uint8_t enc_secded_28_22(const uint8_t bytes[3]);
uint8_t enc_secded_39_32(const uint8_t bytes[4]);
uint8_t enc_secded_64_57(const uint8_t bytes[8]);
uint8_t enc_secded_72_64(const uint8_t bytes[8]);
uint8_t enc_secded_inv_22_16(const uint8_t bytes[2]);
uint8_t enc_secded_inv_28_22(const uint8_t bytes[3]);
uint8_t enc_secded_inv_39_32(const uint8_t bytes[4]);
uint8_t enc_secded_inv_64_57(const uint8_t bytes[8]);
uint8_t enc_secded_inv_72_64(const uint8_t bytes[8]);
#ifdef __cplusplus
} // extern "C"

33
vendor/lowrisc_ip/ip/prim/fpv/prim_secded_inv_22_16_fpv.core vendored Normal file
View file

@ -0,0 +1,33 @@
CAPI=2:
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
name: "lowrisc:fpv:prim_secded_inv_22_16_fpv:0.1"
description: "SECDED FPV target"
filesets:
files_formal:
depend:
- lowrisc:prim:all
- lowrisc:prim:secded
files:
- vip/prim_secded_inv_22_16_assert_fpv.sv
- tb/prim_secded_inv_22_16_tb.sv
- tb/prim_secded_inv_22_16_bind_fpv.sv
file_type: systemVerilogSource
targets:
default: &default_target
# note, this setting is just used
# to generate a file list for jg
default_tool: icarus
filesets:
- files_formal
toplevel:
- prim_secded_inv_22_16_tb
formal:
<<: *default_target
lint:
<<: *default_target

33
vendor/lowrisc_ip/ip/prim/fpv/prim_secded_inv_28_22_fpv.core vendored Normal file
View file

@ -0,0 +1,33 @@
CAPI=2:
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
name: "lowrisc:fpv:prim_secded_inv_28_22_fpv:0.1"
description: "SECDED FPV target"
filesets:
files_formal:
depend:
- lowrisc:prim:all
- lowrisc:prim:secded
files:
- vip/prim_secded_inv_28_22_assert_fpv.sv
- tb/prim_secded_inv_28_22_tb.sv
- tb/prim_secded_inv_28_22_bind_fpv.sv
file_type: systemVerilogSource
targets:
default: &default_target
# note, this setting is just used
# to generate a file list for jg
default_tool: icarus
filesets:
- files_formal
toplevel:
- prim_secded_inv_28_22_tb
formal:
<<: *default_target
lint:
<<: *default_target

33
vendor/lowrisc_ip/ip/prim/fpv/prim_secded_inv_39_32_fpv.core vendored Normal file
View file

@ -0,0 +1,33 @@
CAPI=2:
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
name: "lowrisc:fpv:prim_secded_inv_39_32_fpv:0.1"
description: "SECDED FPV target"
filesets:
files_formal:
depend:
- lowrisc:prim:all
- lowrisc:prim:secded
files:
- vip/prim_secded_inv_39_32_assert_fpv.sv
- tb/prim_secded_inv_39_32_tb.sv
- tb/prim_secded_inv_39_32_bind_fpv.sv
file_type: systemVerilogSource
targets:
default: &default_target
# note, this setting is just used
# to generate a file list for jg
default_tool: icarus
filesets:
- files_formal
toplevel:
- prim_secded_inv_39_32_tb
formal:
<<: *default_target
lint:
<<: *default_target

33
vendor/lowrisc_ip/ip/prim/fpv/prim_secded_inv_64_57_fpv.core vendored Normal file
View file

@ -0,0 +1,33 @@
CAPI=2:
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
name: "lowrisc:fpv:prim_secded_inv_64_57_fpv:0.1"
description: "SECDED FPV target"
filesets:
files_formal:
depend:
- lowrisc:prim:all
- lowrisc:prim:secded
files:
- vip/prim_secded_inv_64_57_assert_fpv.sv
- tb/prim_secded_inv_64_57_tb.sv
- tb/prim_secded_inv_64_57_bind_fpv.sv
file_type: systemVerilogSource
targets:
default: &default_target
# note, this setting is just used
# to generate a file list for jg
default_tool: icarus
filesets:
- files_formal
toplevel:
- prim_secded_inv_64_57_tb
formal:
<<: *default_target
lint:
<<: *default_target

33
vendor/lowrisc_ip/ip/prim/fpv/prim_secded_inv_72_64_fpv.core vendored Normal file
View file

@ -0,0 +1,33 @@
CAPI=2:
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
name: "lowrisc:fpv:prim_secded_inv_72_64_fpv:0.1"
description: "SECDED FPV target"
filesets:
files_formal:
depend:
- lowrisc:prim:all
- lowrisc:prim:secded
files:
- vip/prim_secded_inv_72_64_assert_fpv.sv
- tb/prim_secded_inv_72_64_tb.sv
- tb/prim_secded_inv_72_64_bind_fpv.sv
file_type: systemVerilogSource
targets:
default: &default_target
# note, this setting is just used
# to generate a file list for jg
default_tool: icarus
filesets:
- files_formal
toplevel:
- prim_secded_inv_72_64_tb
formal:
<<: *default_target
lint:
<<: *default_target

33
vendor/lowrisc_ip/ip/prim/fpv/prim_secded_inv_hamming_22_16_fpv.core vendored Normal file
View file

@ -0,0 +1,33 @@
CAPI=2:
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
name: "lowrisc:fpv:prim_secded_inv_hamming_22_16_fpv:0.1"
description: "SECDED FPV target"
filesets:
files_formal:
depend:
- lowrisc:prim:all
- lowrisc:prim:secded
files:
- vip/prim_secded_inv_hamming_22_16_assert_fpv.sv
- tb/prim_secded_inv_hamming_22_16_tb.sv
- tb/prim_secded_inv_hamming_22_16_bind_fpv.sv
file_type: systemVerilogSource
targets:
default: &default_target
# note, this setting is just used
# to generate a file list for jg
default_tool: icarus
filesets:
- files_formal
toplevel:
- prim_secded_inv_hamming_22_16_tb
formal:
<<: *default_target
lint:
<<: *default_target

33
vendor/lowrisc_ip/ip/prim/fpv/prim_secded_inv_hamming_39_32_fpv.core vendored Normal file
View file

@ -0,0 +1,33 @@
CAPI=2:
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
name: "lowrisc:fpv:prim_secded_inv_hamming_39_32_fpv:0.1"
description: "SECDED FPV target"
filesets:
files_formal:
depend:
- lowrisc:prim:all
- lowrisc:prim:secded
files:
- vip/prim_secded_inv_hamming_39_32_assert_fpv.sv
- tb/prim_secded_inv_hamming_39_32_tb.sv
- tb/prim_secded_inv_hamming_39_32_bind_fpv.sv
file_type: systemVerilogSource
targets:
default: &default_target
# note, this setting is just used
# to generate a file list for jg
default_tool: icarus
filesets:
- files_formal
toplevel:
- prim_secded_inv_hamming_39_32_tb
formal:
<<: *default_target
lint:
<<: *default_target

33
vendor/lowrisc_ip/ip/prim/fpv/prim_secded_inv_hamming_72_64_fpv.core vendored Normal file
View file

@ -0,0 +1,33 @@
CAPI=2:
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
name: "lowrisc:fpv:prim_secded_inv_hamming_72_64_fpv:0.1"
description: "SECDED FPV target"
filesets:
files_formal:
depend:
- lowrisc:prim:all
- lowrisc:prim:secded
files:
- vip/prim_secded_inv_hamming_72_64_assert_fpv.sv
- tb/prim_secded_inv_hamming_72_64_tb.sv
- tb/prim_secded_inv_hamming_72_64_bind_fpv.sv
file_type: systemVerilogSource
targets:
default: &default_target
# note, this setting is just used
# to generate a file list for jg
default_tool: icarus
filesets:
- files_formal
toplevel:
- prim_secded_inv_hamming_72_64_tb
formal:
<<: *default_target
lint:
<<: *default_target

33
vendor/lowrisc_ip/ip/prim/fpv/prim_secded_inv_hamming_76_68_fpv.core vendored Normal file
View file

@ -0,0 +1,33 @@
CAPI=2:
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
name: "lowrisc:fpv:prim_secded_inv_hamming_76_68_fpv:0.1"
description: "SECDED FPV target"
filesets:
files_formal:
depend:
- lowrisc:prim:all
- lowrisc:prim:secded
files:
- vip/prim_secded_inv_hamming_76_68_assert_fpv.sv
- tb/prim_secded_inv_hamming_76_68_tb.sv
- tb/prim_secded_inv_hamming_76_68_bind_fpv.sv
file_type: systemVerilogSource
targets:
default: &default_target
# note, this setting is just used
# to generate a file list for jg
default_tool: icarus
filesets:
- files_formal
toplevel:
- prim_secded_inv_hamming_76_68_tb
formal:
<<: *default_target
lint:
<<: *default_target

31
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_hamming_76_68_tb.sv vendored Normal file
View file

@ -0,0 +1,31 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV testbench generated by util/design/secded_gen.py
module prim_secded_hamming_76_68_tb (
input clk_i,
input rst_ni,
input [67:0] data_i,
output logic [67:0] data_o,
output logic [7:0] syndrome_o,
output logic [1:0] err_o,
input [75:0] error_inject_i
);
logic [75:0] data_enc;
prim_secded_hamming_76_68_enc prim_secded_hamming_76_68_enc (
.data_i,
.data_o(data_enc)
);
prim_secded_hamming_76_68_dec prim_secded_hamming_76_68_dec (
.data_i(data_enc ^ error_inject_i),
.data_o,
.syndrome_o,
.err_o
);
endmodule : prim_secded_hamming_76_68_tb

20
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_22_16_bind_fpv.sv vendored Normal file
View file

@ -0,0 +1,20 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV bind file generated by util/design/secded_gen.py
module prim_secded_inv_22_16_bind_fpv;
bind prim_secded_inv_22_16_tb
prim_secded_inv_22_16_assert_fpv prim_secded_inv_22_16_assert_fpv (
.clk_i,
.rst_ni,
.data_i,
.data_o,
.syndrome_o,
.err_o,
.error_inject_i
);
endmodule : prim_secded_inv_22_16_bind_fpv

31
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_22_16_tb.sv vendored Normal file
View file

@ -0,0 +1,31 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV testbench generated by util/design/secded_gen.py
module prim_secded_inv_22_16_tb (
input clk_i,
input rst_ni,
input [15:0] data_i,
output logic [15:0] data_o,
output logic [5:0] syndrome_o,
output logic [1:0] err_o,
input [21:0] error_inject_i
);
logic [21:0] data_enc;
prim_secded_inv_22_16_enc prim_secded_inv_22_16_enc (
.data_i,
.data_o(data_enc)
);
prim_secded_inv_22_16_dec prim_secded_inv_22_16_dec (
.data_i(data_enc ^ error_inject_i),
.data_o,
.syndrome_o,
.err_o
);
endmodule : prim_secded_inv_22_16_tb

20
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_28_22_bind_fpv.sv vendored Normal file
View file

@ -0,0 +1,20 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV bind file generated by util/design/secded_gen.py
module prim_secded_inv_28_22_bind_fpv;
bind prim_secded_inv_28_22_tb
prim_secded_inv_28_22_assert_fpv prim_secded_inv_28_22_assert_fpv (
.clk_i,
.rst_ni,
.data_i,
.data_o,
.syndrome_o,
.err_o,
.error_inject_i
);
endmodule : prim_secded_inv_28_22_bind_fpv

31
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_28_22_tb.sv vendored Normal file
View file

@ -0,0 +1,31 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV testbench generated by util/design/secded_gen.py
module prim_secded_inv_28_22_tb (
input clk_i,
input rst_ni,
input [21:0] data_i,
output logic [21:0] data_o,
output logic [5:0] syndrome_o,
output logic [1:0] err_o,
input [27:0] error_inject_i
);
logic [27:0] data_enc;
prim_secded_inv_28_22_enc prim_secded_inv_28_22_enc (
.data_i,
.data_o(data_enc)
);
prim_secded_inv_28_22_dec prim_secded_inv_28_22_dec (
.data_i(data_enc ^ error_inject_i),
.data_o,
.syndrome_o,
.err_o
);
endmodule : prim_secded_inv_28_22_tb

20
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_39_32_bind_fpv.sv vendored Normal file
View file

@ -0,0 +1,20 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV bind file generated by util/design/secded_gen.py
module prim_secded_inv_39_32_bind_fpv;
bind prim_secded_inv_39_32_tb
prim_secded_inv_39_32_assert_fpv prim_secded_inv_39_32_assert_fpv (
.clk_i,
.rst_ni,
.data_i,
.data_o,
.syndrome_o,
.err_o,
.error_inject_i
);
endmodule : prim_secded_inv_39_32_bind_fpv

31
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_39_32_tb.sv vendored Normal file
View file

@ -0,0 +1,31 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV testbench generated by util/design/secded_gen.py
module prim_secded_inv_39_32_tb (
input clk_i,
input rst_ni,
input [31:0] data_i,
output logic [31:0] data_o,
output logic [6:0] syndrome_o,
output logic [1:0] err_o,
input [38:0] error_inject_i
);
logic [38:0] data_enc;
prim_secded_inv_39_32_enc prim_secded_inv_39_32_enc (
.data_i,
.data_o(data_enc)
);
prim_secded_inv_39_32_dec prim_secded_inv_39_32_dec (
.data_i(data_enc ^ error_inject_i),
.data_o,
.syndrome_o,
.err_o
);
endmodule : prim_secded_inv_39_32_tb

20
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_64_57_bind_fpv.sv vendored Normal file
View file

@ -0,0 +1,20 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV bind file generated by util/design/secded_gen.py
module prim_secded_inv_64_57_bind_fpv;
bind prim_secded_inv_64_57_tb
prim_secded_inv_64_57_assert_fpv prim_secded_inv_64_57_assert_fpv (
.clk_i,
.rst_ni,
.data_i,
.data_o,
.syndrome_o,
.err_o,
.error_inject_i
);
endmodule : prim_secded_inv_64_57_bind_fpv

31
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_64_57_tb.sv vendored Normal file
View file

@ -0,0 +1,31 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV testbench generated by util/design/secded_gen.py
module prim_secded_inv_64_57_tb (
input clk_i,
input rst_ni,
input [56:0] data_i,
output logic [56:0] data_o,
output logic [6:0] syndrome_o,
output logic [1:0] err_o,
input [63:0] error_inject_i
);
logic [63:0] data_enc;
prim_secded_inv_64_57_enc prim_secded_inv_64_57_enc (
.data_i,
.data_o(data_enc)
);
prim_secded_inv_64_57_dec prim_secded_inv_64_57_dec (
.data_i(data_enc ^ error_inject_i),
.data_o,
.syndrome_o,
.err_o
);
endmodule : prim_secded_inv_64_57_tb

20
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_72_64_bind_fpv.sv vendored Normal file
View file

@ -0,0 +1,20 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV bind file generated by util/design/secded_gen.py
module prim_secded_inv_72_64_bind_fpv;
bind prim_secded_inv_72_64_tb
prim_secded_inv_72_64_assert_fpv prim_secded_inv_72_64_assert_fpv (
.clk_i,
.rst_ni,
.data_i,
.data_o,
.syndrome_o,
.err_o,
.error_inject_i
);
endmodule : prim_secded_inv_72_64_bind_fpv

31
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_72_64_tb.sv vendored Normal file
View file

@ -0,0 +1,31 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV testbench generated by util/design/secded_gen.py
module prim_secded_inv_72_64_tb (
input clk_i,
input rst_ni,
input [63:0] data_i,
output logic [63:0] data_o,
output logic [7:0] syndrome_o,
output logic [1:0] err_o,
input [71:0] error_inject_i
);
logic [71:0] data_enc;
prim_secded_inv_72_64_enc prim_secded_inv_72_64_enc (
.data_i,
.data_o(data_enc)
);
prim_secded_inv_72_64_dec prim_secded_inv_72_64_dec (
.data_i(data_enc ^ error_inject_i),
.data_o,
.syndrome_o,
.err_o
);
endmodule : prim_secded_inv_72_64_tb

20
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_hamming_22_16_bind_fpv.sv vendored Normal file
View file

@ -0,0 +1,20 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV bind file generated by util/design/secded_gen.py
module prim_secded_inv_hamming_22_16_bind_fpv;
bind prim_secded_inv_hamming_22_16_tb
prim_secded_inv_hamming_22_16_assert_fpv prim_secded_inv_hamming_22_16_assert_fpv (
.clk_i,
.rst_ni,
.data_i,
.data_o,
.syndrome_o,
.err_o,
.error_inject_i
);
endmodule : prim_secded_inv_hamming_22_16_bind_fpv

31
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_hamming_22_16_tb.sv vendored Normal file
View file

@ -0,0 +1,31 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV testbench generated by util/design/secded_gen.py
module prim_secded_inv_hamming_22_16_tb (
input clk_i,
input rst_ni,
input [15:0] data_i,
output logic [15:0] data_o,
output logic [5:0] syndrome_o,
output logic [1:0] err_o,
input [21:0] error_inject_i
);
logic [21:0] data_enc;
prim_secded_inv_hamming_22_16_enc prim_secded_inv_hamming_22_16_enc (
.data_i,
.data_o(data_enc)
);
prim_secded_inv_hamming_22_16_dec prim_secded_inv_hamming_22_16_dec (
.data_i(data_enc ^ error_inject_i),
.data_o,
.syndrome_o,
.err_o
);
endmodule : prim_secded_inv_hamming_22_16_tb

20
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_hamming_39_32_bind_fpv.sv vendored Normal file
View file

@ -0,0 +1,20 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV bind file generated by util/design/secded_gen.py
module prim_secded_inv_hamming_39_32_bind_fpv;
bind prim_secded_inv_hamming_39_32_tb
prim_secded_inv_hamming_39_32_assert_fpv prim_secded_inv_hamming_39_32_assert_fpv (
.clk_i,
.rst_ni,
.data_i,
.data_o,
.syndrome_o,
.err_o,
.error_inject_i
);
endmodule : prim_secded_inv_hamming_39_32_bind_fpv

31
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_hamming_39_32_tb.sv vendored Normal file
View file

@ -0,0 +1,31 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV testbench generated by util/design/secded_gen.py
module prim_secded_inv_hamming_39_32_tb (
input clk_i,
input rst_ni,
input [31:0] data_i,
output logic [31:0] data_o,
output logic [6:0] syndrome_o,
output logic [1:0] err_o,
input [38:0] error_inject_i
);
logic [38:0] data_enc;
prim_secded_inv_hamming_39_32_enc prim_secded_inv_hamming_39_32_enc (
.data_i,
.data_o(data_enc)
);
prim_secded_inv_hamming_39_32_dec prim_secded_inv_hamming_39_32_dec (
.data_i(data_enc ^ error_inject_i),
.data_o,
.syndrome_o,
.err_o
);
endmodule : prim_secded_inv_hamming_39_32_tb

20
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_hamming_72_64_bind_fpv.sv vendored Normal file
View file

@ -0,0 +1,20 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV bind file generated by util/design/secded_gen.py
module prim_secded_inv_hamming_72_64_bind_fpv;
bind prim_secded_inv_hamming_72_64_tb
prim_secded_inv_hamming_72_64_assert_fpv prim_secded_inv_hamming_72_64_assert_fpv (
.clk_i,
.rst_ni,
.data_i,
.data_o,
.syndrome_o,
.err_o,
.error_inject_i
);
endmodule : prim_secded_inv_hamming_72_64_bind_fpv

31
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_hamming_72_64_tb.sv vendored Normal file
View file

@ -0,0 +1,31 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV testbench generated by util/design/secded_gen.py
module prim_secded_inv_hamming_72_64_tb (
input clk_i,
input rst_ni,
input [63:0] data_i,
output logic [63:0] data_o,
output logic [7:0] syndrome_o,
output logic [1:0] err_o,
input [71:0] error_inject_i
);
logic [71:0] data_enc;
prim_secded_inv_hamming_72_64_enc prim_secded_inv_hamming_72_64_enc (
.data_i,
.data_o(data_enc)
);
prim_secded_inv_hamming_72_64_dec prim_secded_inv_hamming_72_64_dec (
.data_i(data_enc ^ error_inject_i),
.data_o,
.syndrome_o,
.err_o
);
endmodule : prim_secded_inv_hamming_72_64_tb

20
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_hamming_76_68_bind_fpv.sv vendored Normal file
View file

@ -0,0 +1,20 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV bind file generated by util/design/secded_gen.py
module prim_secded_inv_hamming_76_68_bind_fpv;
bind prim_secded_inv_hamming_76_68_tb
prim_secded_inv_hamming_76_68_assert_fpv prim_secded_inv_hamming_76_68_assert_fpv (
.clk_i,
.rst_ni,
.data_i,
.data_o,
.syndrome_o,
.err_o,
.error_inject_i
);
endmodule : prim_secded_inv_hamming_76_68_bind_fpv

31
vendor/lowrisc_ip/ip/prim/fpv/tb/prim_secded_inv_hamming_76_68_tb.sv vendored Normal file
View file

@ -0,0 +1,31 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV testbench generated by util/design/secded_gen.py
module prim_secded_inv_hamming_76_68_tb (
input clk_i,
input rst_ni,
input [67:0] data_i,
output logic [67:0] data_o,
output logic [7:0] syndrome_o,
output logic [1:0] err_o,
input [75:0] error_inject_i
);
logic [75:0] data_enc;
prim_secded_inv_hamming_76_68_enc prim_secded_inv_hamming_76_68_enc (
.data_i,
.data_o(data_enc)
);
prim_secded_inv_hamming_76_68_dec prim_secded_inv_hamming_76_68_dec (
.data_i(data_enc ^ error_inject_i),
.data_o,
.syndrome_o,
.err_o
);
endmodule : prim_secded_inv_hamming_76_68_tb

33
vendor/lowrisc_ip/ip/prim/fpv/vip/prim_secded_hamming_76_68_assert_fpv.sv vendored Normal file
View file

@ -0,0 +1,33 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV assertion file generated by util/design/secded_gen.py
module prim_secded_hamming_76_68_assert_fpv (
input clk_i,
input rst_ni,
input [67:0] data_i,
input [67:0] data_o,
input [7:0] syndrome_o,
input [1:0] err_o,
input [75:0] error_inject_i
);
// Inject a maximum of two errors simultaneously.
`ASSUME_FPV(MaxTwoErrors_M, $countones(error_inject_i) <= 2)
// This bounds the input data state space to make sure the solver converges.
`ASSUME_FPV(DataLimit_M, $onehot0(data_i) || $onehot0(~data_i))
// Single bit error detection
`ASSERT(SingleErrorDetect_A, $countones(error_inject_i) == 1 |-> err_o[0])
`ASSERT(SingleErrorDetectReverse_A, err_o[0] |-> $countones(error_inject_i) == 1)
// Double bit error detection
`ASSERT(DoubleErrorDetect_A, $countones(error_inject_i) == 2 |-> err_o[1])
`ASSERT(DoubleErrorDetectReverse_A, err_o[1] |-> $countones(error_inject_i) == 2)
// Single bit error correction (implicitly tests the syndrome output)
`ASSERT(SingleErrorCorrect_A, $countones(error_inject_i) < 2 |-> data_i == data_o)
// Basic syndrome check
`ASSERT(SyndromeCheck_A, |syndrome_o |-> $countones(error_inject_i) > 0)
`ASSERT(SyndromeCheckReverse_A, $countones(error_inject_i) > 0 |-> |syndrome_o)
endmodule : prim_secded_hamming_76_68_assert_fpv

33
vendor/lowrisc_ip/ip/prim/fpv/vip/prim_secded_inv_22_16_assert_fpv.sv vendored Normal file
View file

@ -0,0 +1,33 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV assertion file generated by util/design/secded_gen.py
module prim_secded_inv_22_16_assert_fpv (
input clk_i,
input rst_ni,
input [15:0] data_i,
input [15:0] data_o,
input [5:0] syndrome_o,
input [1:0] err_o,
input [21:0] error_inject_i
);
// Inject a maximum of two errors simultaneously.
`ASSUME_FPV(MaxTwoErrors_M, $countones(error_inject_i) <= 2)
// This bounds the input data state space to make sure the solver converges.
`ASSUME_FPV(DataLimit_M, $onehot0(data_i) || $onehot0(~data_i))
// Single bit error detection
`ASSERT(SingleErrorDetect_A, $countones(error_inject_i) == 1 |-> err_o[0])
`ASSERT(SingleErrorDetectReverse_A, err_o[0] |-> $countones(error_inject_i) == 1)
// Double bit error detection
`ASSERT(DoubleErrorDetect_A, $countones(error_inject_i) == 2 |-> err_o[1])
`ASSERT(DoubleErrorDetectReverse_A, err_o[1] |-> $countones(error_inject_i) == 2)
// Single bit error correction (implicitly tests the syndrome output)
`ASSERT(SingleErrorCorrect_A, $countones(error_inject_i) < 2 |-> data_i == data_o)
// Basic syndrome check
`ASSERT(SyndromeCheck_A, |syndrome_o |-> $countones(error_inject_i) > 0)
`ASSERT(SyndromeCheckReverse_A, $countones(error_inject_i) > 0 |-> |syndrome_o)
endmodule : prim_secded_inv_22_16_assert_fpv

33
vendor/lowrisc_ip/ip/prim/fpv/vip/prim_secded_inv_28_22_assert_fpv.sv vendored Normal file
View file

@ -0,0 +1,33 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV assertion file generated by util/design/secded_gen.py
module prim_secded_inv_28_22_assert_fpv (
input clk_i,
input rst_ni,
input [21:0] data_i,
input [21:0] data_o,
input [5:0] syndrome_o,
input [1:0] err_o,
input [27:0] error_inject_i
);
// Inject a maximum of two errors simultaneously.
`ASSUME_FPV(MaxTwoErrors_M, $countones(error_inject_i) <= 2)
// This bounds the input data state space to make sure the solver converges.
`ASSUME_FPV(DataLimit_M, $onehot0(data_i) || $onehot0(~data_i))
// Single bit error detection
`ASSERT(SingleErrorDetect_A, $countones(error_inject_i) == 1 |-> err_o[0])
`ASSERT(SingleErrorDetectReverse_A, err_o[0] |-> $countones(error_inject_i) == 1)
// Double bit error detection
`ASSERT(DoubleErrorDetect_A, $countones(error_inject_i) == 2 |-> err_o[1])
`ASSERT(DoubleErrorDetectReverse_A, err_o[1] |-> $countones(error_inject_i) == 2)
// Single bit error correction (implicitly tests the syndrome output)
`ASSERT(SingleErrorCorrect_A, $countones(error_inject_i) < 2 |-> data_i == data_o)
// Basic syndrome check
`ASSERT(SyndromeCheck_A, |syndrome_o |-> $countones(error_inject_i) > 0)
`ASSERT(SyndromeCheckReverse_A, $countones(error_inject_i) > 0 |-> |syndrome_o)
endmodule : prim_secded_inv_28_22_assert_fpv

33
vendor/lowrisc_ip/ip/prim/fpv/vip/prim_secded_inv_39_32_assert_fpv.sv vendored Normal file
View file

@ -0,0 +1,33 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV assertion file generated by util/design/secded_gen.py
module prim_secded_inv_39_32_assert_fpv (
input clk_i,
input rst_ni,
input [31:0] data_i,
input [31:0] data_o,
input [6:0] syndrome_o,
input [1:0] err_o,
input [38:0] error_inject_i
);
// Inject a maximum of two errors simultaneously.
`ASSUME_FPV(MaxTwoErrors_M, $countones(error_inject_i) <= 2)
// This bounds the input data state space to make sure the solver converges.
`ASSUME_FPV(DataLimit_M, $onehot0(data_i) || $onehot0(~data_i))
// Single bit error detection
`ASSERT(SingleErrorDetect_A, $countones(error_inject_i) == 1 |-> err_o[0])
`ASSERT(SingleErrorDetectReverse_A, err_o[0] |-> $countones(error_inject_i) == 1)
// Double bit error detection
`ASSERT(DoubleErrorDetect_A, $countones(error_inject_i) == 2 |-> err_o[1])
`ASSERT(DoubleErrorDetectReverse_A, err_o[1] |-> $countones(error_inject_i) == 2)
// Single bit error correction (implicitly tests the syndrome output)
`ASSERT(SingleErrorCorrect_A, $countones(error_inject_i) < 2 |-> data_i == data_o)
// Basic syndrome check
`ASSERT(SyndromeCheck_A, |syndrome_o |-> $countones(error_inject_i) > 0)
`ASSERT(SyndromeCheckReverse_A, $countones(error_inject_i) > 0 |-> |syndrome_o)
endmodule : prim_secded_inv_39_32_assert_fpv

33
vendor/lowrisc_ip/ip/prim/fpv/vip/prim_secded_inv_64_57_assert_fpv.sv vendored Normal file
View file

@ -0,0 +1,33 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV assertion file generated by util/design/secded_gen.py
module prim_secded_inv_64_57_assert_fpv (
input clk_i,
input rst_ni,
input [56:0] data_i,
input [56:0] data_o,
input [6:0] syndrome_o,
input [1:0] err_o,
input [63:0] error_inject_i
);
// Inject a maximum of two errors simultaneously.
`ASSUME_FPV(MaxTwoErrors_M, $countones(error_inject_i) <= 2)
// This bounds the input data state space to make sure the solver converges.
`ASSUME_FPV(DataLimit_M, $onehot0(data_i) || $onehot0(~data_i))
// Single bit error detection
`ASSERT(SingleErrorDetect_A, $countones(error_inject_i) == 1 |-> err_o[0])
`ASSERT(SingleErrorDetectReverse_A, err_o[0] |-> $countones(error_inject_i) == 1)
// Double bit error detection
`ASSERT(DoubleErrorDetect_A, $countones(error_inject_i) == 2 |-> err_o[1])
`ASSERT(DoubleErrorDetectReverse_A, err_o[1] |-> $countones(error_inject_i) == 2)
// Single bit error correction (implicitly tests the syndrome output)
`ASSERT(SingleErrorCorrect_A, $countones(error_inject_i) < 2 |-> data_i == data_o)
// Basic syndrome check
`ASSERT(SyndromeCheck_A, |syndrome_o |-> $countones(error_inject_i) > 0)
`ASSERT(SyndromeCheckReverse_A, $countones(error_inject_i) > 0 |-> |syndrome_o)
endmodule : prim_secded_inv_64_57_assert_fpv

33
vendor/lowrisc_ip/ip/prim/fpv/vip/prim_secded_inv_72_64_assert_fpv.sv vendored Normal file
View file

@ -0,0 +1,33 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV assertion file generated by util/design/secded_gen.py
module prim_secded_inv_72_64_assert_fpv (
input clk_i,
input rst_ni,
input [63:0] data_i,
input [63:0] data_o,
input [7:0] syndrome_o,
input [1:0] err_o,
input [71:0] error_inject_i
);
// Inject a maximum of two errors simultaneously.
`ASSUME_FPV(MaxTwoErrors_M, $countones(error_inject_i) <= 2)
// This bounds the input data state space to make sure the solver converges.
`ASSUME_FPV(DataLimit_M, $onehot0(data_i) || $onehot0(~data_i))
// Single bit error detection
`ASSERT(SingleErrorDetect_A, $countones(error_inject_i) == 1 |-> err_o[0])
`ASSERT(SingleErrorDetectReverse_A, err_o[0] |-> $countones(error_inject_i) == 1)
// Double bit error detection
`ASSERT(DoubleErrorDetect_A, $countones(error_inject_i) == 2 |-> err_o[1])
`ASSERT(DoubleErrorDetectReverse_A, err_o[1] |-> $countones(error_inject_i) == 2)
// Single bit error correction (implicitly tests the syndrome output)
`ASSERT(SingleErrorCorrect_A, $countones(error_inject_i) < 2 |-> data_i == data_o)
// Basic syndrome check
`ASSERT(SyndromeCheck_A, |syndrome_o |-> $countones(error_inject_i) > 0)
`ASSERT(SyndromeCheckReverse_A, $countones(error_inject_i) > 0 |-> |syndrome_o)
endmodule : prim_secded_inv_72_64_assert_fpv

33
vendor/lowrisc_ip/ip/prim/fpv/vip/prim_secded_inv_hamming_22_16_assert_fpv.sv vendored Normal file
View file

@ -0,0 +1,33 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV assertion file generated by util/design/secded_gen.py
module prim_secded_inv_hamming_22_16_assert_fpv (
input clk_i,
input rst_ni,
input [15:0] data_i,
input [15:0] data_o,
input [5:0] syndrome_o,
input [1:0] err_o,
input [21:0] error_inject_i
);
// Inject a maximum of two errors simultaneously.
`ASSUME_FPV(MaxTwoErrors_M, $countones(error_inject_i) <= 2)
// This bounds the input data state space to make sure the solver converges.
`ASSUME_FPV(DataLimit_M, $onehot0(data_i) || $onehot0(~data_i))
// Single bit error detection
`ASSERT(SingleErrorDetect_A, $countones(error_inject_i) == 1 |-> err_o[0])
`ASSERT(SingleErrorDetectReverse_A, err_o[0] |-> $countones(error_inject_i) == 1)
// Double bit error detection
`ASSERT(DoubleErrorDetect_A, $countones(error_inject_i) == 2 |-> err_o[1])
`ASSERT(DoubleErrorDetectReverse_A, err_o[1] |-> $countones(error_inject_i) == 2)
// Single bit error correction (implicitly tests the syndrome output)
`ASSERT(SingleErrorCorrect_A, $countones(error_inject_i) < 2 |-> data_i == data_o)
// Basic syndrome check
`ASSERT(SyndromeCheck_A, |syndrome_o |-> $countones(error_inject_i) > 0)
`ASSERT(SyndromeCheckReverse_A, $countones(error_inject_i) > 0 |-> |syndrome_o)
endmodule : prim_secded_inv_hamming_22_16_assert_fpv

33
vendor/lowrisc_ip/ip/prim/fpv/vip/prim_secded_inv_hamming_39_32_assert_fpv.sv vendored Normal file
View file

@ -0,0 +1,33 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV assertion file generated by util/design/secded_gen.py
module prim_secded_inv_hamming_39_32_assert_fpv (
input clk_i,
input rst_ni,
input [31:0] data_i,
input [31:0] data_o,
input [6:0] syndrome_o,
input [1:0] err_o,
input [38:0] error_inject_i
);
// Inject a maximum of two errors simultaneously.
`ASSUME_FPV(MaxTwoErrors_M, $countones(error_inject_i) <= 2)
// This bounds the input data state space to make sure the solver converges.
`ASSUME_FPV(DataLimit_M, $onehot0(data_i) || $onehot0(~data_i))
// Single bit error detection
`ASSERT(SingleErrorDetect_A, $countones(error_inject_i) == 1 |-> err_o[0])
`ASSERT(SingleErrorDetectReverse_A, err_o[0] |-> $countones(error_inject_i) == 1)
// Double bit error detection
`ASSERT(DoubleErrorDetect_A, $countones(error_inject_i) == 2 |-> err_o[1])
`ASSERT(DoubleErrorDetectReverse_A, err_o[1] |-> $countones(error_inject_i) == 2)
// Single bit error correction (implicitly tests the syndrome output)
`ASSERT(SingleErrorCorrect_A, $countones(error_inject_i) < 2 |-> data_i == data_o)
// Basic syndrome check
`ASSERT(SyndromeCheck_A, |syndrome_o |-> $countones(error_inject_i) > 0)
`ASSERT(SyndromeCheckReverse_A, $countones(error_inject_i) > 0 |-> |syndrome_o)
endmodule : prim_secded_inv_hamming_39_32_assert_fpv

33
vendor/lowrisc_ip/ip/prim/fpv/vip/prim_secded_inv_hamming_72_64_assert_fpv.sv vendored Normal file
View file

@ -0,0 +1,33 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV assertion file generated by util/design/secded_gen.py
module prim_secded_inv_hamming_72_64_assert_fpv (
input clk_i,
input rst_ni,
input [63:0] data_i,
input [63:0] data_o,
input [7:0] syndrome_o,
input [1:0] err_o,
input [71:0] error_inject_i
);
// Inject a maximum of two errors simultaneously.
`ASSUME_FPV(MaxTwoErrors_M, $countones(error_inject_i) <= 2)
// This bounds the input data state space to make sure the solver converges.
`ASSUME_FPV(DataLimit_M, $onehot0(data_i) || $onehot0(~data_i))
// Single bit error detection
`ASSERT(SingleErrorDetect_A, $countones(error_inject_i) == 1 |-> err_o[0])
`ASSERT(SingleErrorDetectReverse_A, err_o[0] |-> $countones(error_inject_i) == 1)
// Double bit error detection
`ASSERT(DoubleErrorDetect_A, $countones(error_inject_i) == 2 |-> err_o[1])
`ASSERT(DoubleErrorDetectReverse_A, err_o[1] |-> $countones(error_inject_i) == 2)
// Single bit error correction (implicitly tests the syndrome output)
`ASSERT(SingleErrorCorrect_A, $countones(error_inject_i) < 2 |-> data_i == data_o)
// Basic syndrome check
`ASSERT(SyndromeCheck_A, |syndrome_o |-> $countones(error_inject_i) > 0)
`ASSERT(SyndromeCheckReverse_A, $countones(error_inject_i) > 0 |-> |syndrome_o)
endmodule : prim_secded_inv_hamming_72_64_assert_fpv

33
vendor/lowrisc_ip/ip/prim/fpv/vip/prim_secded_inv_hamming_76_68_assert_fpv.sv vendored Normal file
View file

@ -0,0 +1,33 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED FPV assertion file generated by util/design/secded_gen.py
module prim_secded_inv_hamming_76_68_assert_fpv (
input clk_i,
input rst_ni,
input [67:0] data_i,
input [67:0] data_o,
input [7:0] syndrome_o,
input [1:0] err_o,
input [75:0] error_inject_i
);
// Inject a maximum of two errors simultaneously.
`ASSUME_FPV(MaxTwoErrors_M, $countones(error_inject_i) <= 2)
// This bounds the input data state space to make sure the solver converges.
`ASSUME_FPV(DataLimit_M, $onehot0(data_i) || $onehot0(~data_i))
// Single bit error detection
`ASSERT(SingleErrorDetect_A, $countones(error_inject_i) == 1 |-> err_o[0])
`ASSERT(SingleErrorDetectReverse_A, err_o[0] |-> $countones(error_inject_i) == 1)
// Double bit error detection
`ASSERT(DoubleErrorDetect_A, $countones(error_inject_i) == 2 |-> err_o[1])
`ASSERT(DoubleErrorDetectReverse_A, err_o[1] |-> $countones(error_inject_i) == 2)
// Single bit error correction (implicitly tests the syndrome output)
`ASSERT(SingleErrorCorrect_A, $countones(error_inject_i) < 2 |-> data_i == data_o)
// Basic syndrome check
`ASSERT(SyndromeCheck_A, |syndrome_o |-> $countones(error_inject_i) > 0)
`ASSERT(SyndromeCheckReverse_A, $countones(error_inject_i) > 0 |-> |syndrome_o)
endmodule : prim_secded_inv_hamming_76_68_assert_fpv

18
vendor/lowrisc_ip/ip/prim/prim_secded.core vendored
View file

@ -27,6 +27,24 @@ filesets:
- rtl/prim_secded_hamming_72_64_enc.sv
- rtl/prim_secded_hamming_76_68_dec.sv
- rtl/prim_secded_hamming_76_68_enc.sv
- rtl/prim_secded_inv_22_16_dec.sv
- rtl/prim_secded_inv_22_16_enc.sv
- rtl/prim_secded_inv_28_22_dec.sv
- rtl/prim_secded_inv_28_22_enc.sv
- rtl/prim_secded_inv_39_32_dec.sv
- rtl/prim_secded_inv_39_32_enc.sv
- rtl/prim_secded_inv_64_57_dec.sv
- rtl/prim_secded_inv_64_57_enc.sv
- rtl/prim_secded_inv_72_64_dec.sv
- rtl/prim_secded_inv_72_64_enc.sv
- rtl/prim_secded_inv_hamming_22_16_dec.sv
- rtl/prim_secded_inv_hamming_22_16_enc.sv
- rtl/prim_secded_inv_hamming_39_32_dec.sv
- rtl/prim_secded_inv_hamming_39_32_enc.sv
- rtl/prim_secded_inv_hamming_72_64_dec.sv
- rtl/prim_secded_inv_hamming_72_64_enc.sv
- rtl/prim_secded_inv_hamming_76_68_dec.sv
- rtl/prim_secded_inv_hamming_76_68_enc.sv
file_type: systemVerilogSource
targets:

37
vendor/lowrisc_ip/ip/prim/prim_sparse_fsm.core vendored Normal file
View file

@ -0,0 +1,37 @@
CAPI=2:
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
name: "lowrisc:prim:sparse_fsm"
description: ""
filesets:
files_rtl:
depend:
- lowrisc:prim:assert
files:
- rtl/prim_sparse_fsm_flop.sv
file_type: systemVerilogSource
files_verilator_waiver:
depend:
# common waivers
- lowrisc:lint:common
files_ascentlint_waiver:
depend:
# common waivers
- lowrisc:lint:common
files_veriblelint_waiver:
depend:
# common waivers
- lowrisc:lint:common
targets:
default:
filesets:
- tool_verilator ? (files_verilator_waiver)
- tool_ascentlint ? (files_ascentlint_waiver)
- tool_veriblelint ? (files_veriblelint_waiver)
- files_rtl

5
vendor/lowrisc_ip/ip/prim/rtl/prim_alert_receiver.sv vendored
View file

@ -57,7 +57,6 @@ module prim_alert_receiver
);
import prim_mubi_pkg::mubi4_test_true_strict;
import prim_mubi_pkg::mubi4_test_false_loose;
/////////////////////////////////
// decode differential signals //
@ -258,6 +257,10 @@ module prim_alert_receiver
// assertions //
////////////////
`ifdef INC_ASSERT
import prim_mubi_pkg::mubi4_test_false_loose;
`endif
// check whether all outputs have a good known state after reset
`ASSERT_KNOWN(PingOkKnownO_A, ping_ok_o)
`ASSERT_KNOWN(IntegFailKnownO_A, integ_fail_o)

4
vendor/lowrisc_ip/ip/prim/rtl/prim_clock_div.sv vendored
View file

@ -77,8 +77,8 @@ module prim_clock_div #(
logic [CntWidth-1:0] cnt;
logic [CntWidth-1:0] limit;
assign limit = !step_down_req ? ToggleCnt - 1 :
(ToggleCnt / 2) == 2 ? '0 : (ToggleCnt / 2) - 1;
assign limit = !step_down_req ? CntWidth'(ToggleCnt - 1) :
(ToggleCnt / 2) == 2 ? '0 : CntWidth'((ToggleCnt / 2) - 1);
always_ff @(posedge clk_i or negedge rst_ni) begin
if (!rst_ni) begin

4
vendor/lowrisc_ip/ip/prim/rtl/prim_lc_sync.sv vendored
View file

@ -30,7 +30,7 @@ module prim_lc_sync #(
output lc_ctrl_pkg::lc_tx_t [NumCopies-1:0] lc_en_o
);
localparam lc_ctrl_pkg::lc_tx_t ResetValue = (ResetValueIsOn) ? lc_ctrl_pkg::On :
localparam lc_ctrl_pkg::lc_tx_t LcResetValue = (ResetValueIsOn) ? lc_ctrl_pkg::On :
lc_ctrl_pkg::Off;
`ASSERT_INIT(NumCopiesMustBeGreaterZero_A, NumCopies > 0)
@ -39,7 +39,7 @@ module prim_lc_sync #(
if (AsyncOn) begin : gen_flops
prim_flop_2sync #(
.Width(lc_ctrl_pkg::TxWidth),
.ResetValue(lc_ctrl_pkg::TxWidth'(ResetValue))
.ResetValue(lc_ctrl_pkg::TxWidth'(LcResetValue))
) u_prim_flop_2sync (
.clk_i,
.rst_ni,

60
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_22_16_dec.sv vendored
View file

@ -11,37 +11,35 @@ module prim_secded_22_16_dec (
output logic [1:0] err_o
);
logic single_error;
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^(data_i & 22'h01496E);
syndrome_o[1] = ^(data_i & 22'h02F20B);
syndrome_o[2] = ^(data_i & 22'h048ED8);
syndrome_o[3] = ^(data_i & 22'h087714);
syndrome_o[4] = ^(data_i & 22'h10ACA5);
syndrome_o[5] = ^(data_i & 22'h2011F3);
// Syndrome calculation
assign syndrome_o[0] = ^(data_i & 22'h01496E);
assign syndrome_o[1] = ^(data_i & 22'h02F20B);
assign syndrome_o[2] = ^(data_i & 22'h048ED8);
assign syndrome_o[3] = ^(data_i & 22'h087714);
assign syndrome_o[4] = ^(data_i & 22'h10ACA5);
assign syndrome_o[5] = ^(data_i & 22'h2011F3);
// Corrected output calculation
assign data_o[0] = (syndrome_o == 6'h32) ^ data_i[0];
assign data_o[1] = (syndrome_o == 6'h23) ^ data_i[1];
assign data_o[2] = (syndrome_o == 6'h19) ^ data_i[2];
assign data_o[3] = (syndrome_o == 6'h7) ^ data_i[3];
assign data_o[4] = (syndrome_o == 6'h2c) ^ data_i[4];
assign data_o[5] = (syndrome_o == 6'h31) ^ data_i[5];
assign data_o[6] = (syndrome_o == 6'h25) ^ data_i[6];
assign data_o[7] = (syndrome_o == 6'h34) ^ data_i[7];
assign data_o[8] = (syndrome_o == 6'h29) ^ data_i[8];
assign data_o[9] = (syndrome_o == 6'he) ^ data_i[9];
assign data_o[10] = (syndrome_o == 6'h1c) ^ data_i[10];
assign data_o[11] = (syndrome_o == 6'h15) ^ data_i[11];
assign data_o[12] = (syndrome_o == 6'h2a) ^ data_i[12];
assign data_o[13] = (syndrome_o == 6'h1a) ^ data_i[13];
assign data_o[14] = (syndrome_o == 6'hb) ^ data_i[14];
assign data_o[15] = (syndrome_o == 6'h16) ^ data_i[15];
// err_o calc. bit0: single error, bit1: double error
assign single_error = ^syndrome_o;
assign err_o[0] = single_error;
assign err_o[1] = ~single_error & (|syndrome_o);
// Corrected output calculation
data_o[0] = (syndrome_o == 6'h32) ^ data_i[0];
data_o[1] = (syndrome_o == 6'h23) ^ data_i[1];
data_o[2] = (syndrome_o == 6'h19) ^ data_i[2];
data_o[3] = (syndrome_o == 6'h7) ^ data_i[3];
data_o[4] = (syndrome_o == 6'h2c) ^ data_i[4];
data_o[5] = (syndrome_o == 6'h31) ^ data_i[5];
data_o[6] = (syndrome_o == 6'h25) ^ data_i[6];
data_o[7] = (syndrome_o == 6'h34) ^ data_i[7];
data_o[8] = (syndrome_o == 6'h29) ^ data_i[8];
data_o[9] = (syndrome_o == 6'he) ^ data_i[9];
data_o[10] = (syndrome_o == 6'h1c) ^ data_i[10];
data_o[11] = (syndrome_o == 6'h15) ^ data_i[11];
data_o[12] = (syndrome_o == 6'h2a) ^ data_i[12];
data_o[13] = (syndrome_o == 6'h1a) ^ data_i[13];
data_o[14] = (syndrome_o == 6'hb) ^ data_i[14];
data_o[15] = (syndrome_o == 6'h16) ^ data_i[15];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = ^syndrome_o;
err_o[1] = ~err_o[0] & (|syndrome_o);
end
endmodule : prim_secded_22_16_dec

72
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_28_22_dec.sv vendored
View file

@ -11,43 +11,41 @@ module prim_secded_28_22_dec (
output logic [1:0] err_o
);
logic single_error;
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^(data_i & 28'h07003FF);
syndrome_o[1] = ^(data_i & 28'h090FC0F);
syndrome_o[2] = ^(data_i & 28'h1271C71);
syndrome_o[3] = ^(data_i & 28'h23B6592);
syndrome_o[4] = ^(data_i & 28'h43DAAA4);
syndrome_o[5] = ^(data_i & 28'h83ED348);
// Syndrome calculation
assign syndrome_o[0] = ^(data_i & 28'h07003FF);
assign syndrome_o[1] = ^(data_i & 28'h090FC0F);
assign syndrome_o[2] = ^(data_i & 28'h1271C71);
assign syndrome_o[3] = ^(data_i & 28'h23B6592);
assign syndrome_o[4] = ^(data_i & 28'h43DAAA4);
assign syndrome_o[5] = ^(data_i & 28'h83ED348);
// Corrected output calculation
assign data_o[0] = (syndrome_o == 6'h7) ^ data_i[0];
assign data_o[1] = (syndrome_o == 6'hb) ^ data_i[1];
assign data_o[2] = (syndrome_o == 6'h13) ^ data_i[2];
assign data_o[3] = (syndrome_o == 6'h23) ^ data_i[3];
assign data_o[4] = (syndrome_o == 6'hd) ^ data_i[4];
assign data_o[5] = (syndrome_o == 6'h15) ^ data_i[5];
assign data_o[6] = (syndrome_o == 6'h25) ^ data_i[6];
assign data_o[7] = (syndrome_o == 6'h19) ^ data_i[7];
assign data_o[8] = (syndrome_o == 6'h29) ^ data_i[8];
assign data_o[9] = (syndrome_o == 6'h31) ^ data_i[9];
assign data_o[10] = (syndrome_o == 6'he) ^ data_i[10];
assign data_o[11] = (syndrome_o == 6'h16) ^ data_i[11];
assign data_o[12] = (syndrome_o == 6'h26) ^ data_i[12];
assign data_o[13] = (syndrome_o == 6'h1a) ^ data_i[13];
assign data_o[14] = (syndrome_o == 6'h2a) ^ data_i[14];
assign data_o[15] = (syndrome_o == 6'h32) ^ data_i[15];
assign data_o[16] = (syndrome_o == 6'h1c) ^ data_i[16];
assign data_o[17] = (syndrome_o == 6'h2c) ^ data_i[17];
assign data_o[18] = (syndrome_o == 6'h34) ^ data_i[18];
assign data_o[19] = (syndrome_o == 6'h38) ^ data_i[19];
assign data_o[20] = (syndrome_o == 6'h3b) ^ data_i[20];
assign data_o[21] = (syndrome_o == 6'h3d) ^ data_i[21];
// err_o calc. bit0: single error, bit1: double error
assign single_error = ^syndrome_o;
assign err_o[0] = single_error;
assign err_o[1] = ~single_error & (|syndrome_o);
// Corrected output calculation
data_o[0] = (syndrome_o == 6'h7) ^ data_i[0];
data_o[1] = (syndrome_o == 6'hb) ^ data_i[1];
data_o[2] = (syndrome_o == 6'h13) ^ data_i[2];
data_o[3] = (syndrome_o == 6'h23) ^ data_i[3];
data_o[4] = (syndrome_o == 6'hd) ^ data_i[4];
data_o[5] = (syndrome_o == 6'h15) ^ data_i[5];
data_o[6] = (syndrome_o == 6'h25) ^ data_i[6];
data_o[7] = (syndrome_o == 6'h19) ^ data_i[7];
data_o[8] = (syndrome_o == 6'h29) ^ data_i[8];
data_o[9] = (syndrome_o == 6'h31) ^ data_i[9];
data_o[10] = (syndrome_o == 6'he) ^ data_i[10];
data_o[11] = (syndrome_o == 6'h16) ^ data_i[11];
data_o[12] = (syndrome_o == 6'h26) ^ data_i[12];
data_o[13] = (syndrome_o == 6'h1a) ^ data_i[13];
data_o[14] = (syndrome_o == 6'h2a) ^ data_i[14];
data_o[15] = (syndrome_o == 6'h32) ^ data_i[15];
data_o[16] = (syndrome_o == 6'h1c) ^ data_i[16];
data_o[17] = (syndrome_o == 6'h2c) ^ data_i[17];
data_o[18] = (syndrome_o == 6'h34) ^ data_i[18];
data_o[19] = (syndrome_o == 6'h38) ^ data_i[19];
data_o[20] = (syndrome_o == 6'h3b) ^ data_i[20];
data_o[21] = (syndrome_o == 6'h3d) ^ data_i[21];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = ^syndrome_o;
err_o[1] = ~err_o[0] & (|syndrome_o);
end
endmodule : prim_secded_28_22_dec

94
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_39_32_dec.sv vendored
View file

@ -11,54 +11,52 @@ module prim_secded_39_32_dec (
output logic [1:0] err_o
);
logic single_error;
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^(data_i & 39'h012606BD25);
syndrome_o[1] = ^(data_i & 39'h02DEBA8050);
syndrome_o[2] = ^(data_i & 39'h04413D89AA);
syndrome_o[3] = ^(data_i & 39'h0831234ED1);
syndrome_o[4] = ^(data_i & 39'h10C2C1323B);
syndrome_o[5] = ^(data_i & 39'h202DCC624C);
syndrome_o[6] = ^(data_i & 39'h4098505586);
// Syndrome calculation
assign syndrome_o[0] = ^(data_i & 39'h012606BD25);
assign syndrome_o[1] = ^(data_i & 39'h02DEBA8050);
assign syndrome_o[2] = ^(data_i & 39'h04413D89AA);
assign syndrome_o[3] = ^(data_i & 39'h0831234ED1);
assign syndrome_o[4] = ^(data_i & 39'h10C2C1323B);
assign syndrome_o[5] = ^(data_i & 39'h202DCC624C);
assign syndrome_o[6] = ^(data_i & 39'h4098505586);
// Corrected output calculation
assign data_o[0] = (syndrome_o == 7'h19) ^ data_i[0];
assign data_o[1] = (syndrome_o == 7'h54) ^ data_i[1];
assign data_o[2] = (syndrome_o == 7'h61) ^ data_i[2];
assign data_o[3] = (syndrome_o == 7'h34) ^ data_i[3];
assign data_o[4] = (syndrome_o == 7'h1a) ^ data_i[4];
assign data_o[5] = (syndrome_o == 7'h15) ^ data_i[5];
assign data_o[6] = (syndrome_o == 7'h2a) ^ data_i[6];
assign data_o[7] = (syndrome_o == 7'h4c) ^ data_i[7];
assign data_o[8] = (syndrome_o == 7'h45) ^ data_i[8];
assign data_o[9] = (syndrome_o == 7'h38) ^ data_i[9];
assign data_o[10] = (syndrome_o == 7'h49) ^ data_i[10];
assign data_o[11] = (syndrome_o == 7'hd) ^ data_i[11];
assign data_o[12] = (syndrome_o == 7'h51) ^ data_i[12];
assign data_o[13] = (syndrome_o == 7'h31) ^ data_i[13];
assign data_o[14] = (syndrome_o == 7'h68) ^ data_i[14];
assign data_o[15] = (syndrome_o == 7'h7) ^ data_i[15];
assign data_o[16] = (syndrome_o == 7'h1c) ^ data_i[16];
assign data_o[17] = (syndrome_o == 7'hb) ^ data_i[17];
assign data_o[18] = (syndrome_o == 7'h25) ^ data_i[18];
assign data_o[19] = (syndrome_o == 7'h26) ^ data_i[19];
assign data_o[20] = (syndrome_o == 7'h46) ^ data_i[20];
assign data_o[21] = (syndrome_o == 7'he) ^ data_i[21];
assign data_o[22] = (syndrome_o == 7'h70) ^ data_i[22];
assign data_o[23] = (syndrome_o == 7'h32) ^ data_i[23];
assign data_o[24] = (syndrome_o == 7'h2c) ^ data_i[24];
assign data_o[25] = (syndrome_o == 7'h13) ^ data_i[25];
assign data_o[26] = (syndrome_o == 7'h23) ^ data_i[26];
assign data_o[27] = (syndrome_o == 7'h62) ^ data_i[27];
assign data_o[28] = (syndrome_o == 7'h4a) ^ data_i[28];
assign data_o[29] = (syndrome_o == 7'h29) ^ data_i[29];
assign data_o[30] = (syndrome_o == 7'h16) ^ data_i[30];
assign data_o[31] = (syndrome_o == 7'h52) ^ data_i[31];
// err_o calc. bit0: single error, bit1: double error
assign single_error = ^syndrome_o;
assign err_o[0] = single_error;
assign err_o[1] = ~single_error & (|syndrome_o);
// Corrected output calculation
data_o[0] = (syndrome_o == 7'h19) ^ data_i[0];
data_o[1] = (syndrome_o == 7'h54) ^ data_i[1];
data_o[2] = (syndrome_o == 7'h61) ^ data_i[2];
data_o[3] = (syndrome_o == 7'h34) ^ data_i[3];
data_o[4] = (syndrome_o == 7'h1a) ^ data_i[4];
data_o[5] = (syndrome_o == 7'h15) ^ data_i[5];
data_o[6] = (syndrome_o == 7'h2a) ^ data_i[6];
data_o[7] = (syndrome_o == 7'h4c) ^ data_i[7];
data_o[8] = (syndrome_o == 7'h45) ^ data_i[8];
data_o[9] = (syndrome_o == 7'h38) ^ data_i[9];
data_o[10] = (syndrome_o == 7'h49) ^ data_i[10];
data_o[11] = (syndrome_o == 7'hd) ^ data_i[11];
data_o[12] = (syndrome_o == 7'h51) ^ data_i[12];
data_o[13] = (syndrome_o == 7'h31) ^ data_i[13];
data_o[14] = (syndrome_o == 7'h68) ^ data_i[14];
data_o[15] = (syndrome_o == 7'h7) ^ data_i[15];
data_o[16] = (syndrome_o == 7'h1c) ^ data_i[16];
data_o[17] = (syndrome_o == 7'hb) ^ data_i[17];
data_o[18] = (syndrome_o == 7'h25) ^ data_i[18];
data_o[19] = (syndrome_o == 7'h26) ^ data_i[19];
data_o[20] = (syndrome_o == 7'h46) ^ data_i[20];
data_o[21] = (syndrome_o == 7'he) ^ data_i[21];
data_o[22] = (syndrome_o == 7'h70) ^ data_i[22];
data_o[23] = (syndrome_o == 7'h32) ^ data_i[23];
data_o[24] = (syndrome_o == 7'h2c) ^ data_i[24];
data_o[25] = (syndrome_o == 7'h13) ^ data_i[25];
data_o[26] = (syndrome_o == 7'h23) ^ data_i[26];
data_o[27] = (syndrome_o == 7'h62) ^ data_i[27];
data_o[28] = (syndrome_o == 7'h4a) ^ data_i[28];
data_o[29] = (syndrome_o == 7'h29) ^ data_i[29];
data_o[30] = (syndrome_o == 7'h16) ^ data_i[30];
data_o[31] = (syndrome_o == 7'h52) ^ data_i[31];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = ^syndrome_o;
err_o[1] = ~err_o[0] & (|syndrome_o);
end
endmodule : prim_secded_39_32_dec

144
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_64_57_dec.sv vendored
View file

@ -11,79 +11,77 @@ module prim_secded_64_57_dec (
output logic [1:0] err_o
);
logic single_error;
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^(data_i & 64'h0303FFF800007FFF);
syndrome_o[1] = ^(data_i & 64'h057C1FF801FF801F);
syndrome_o[2] = ^(data_i & 64'h09BDE1F87E0781E1);
syndrome_o[3] = ^(data_i & 64'h11DEEE3B8E388E22);
syndrome_o[4] = ^(data_i & 64'h21EF76CDB2C93244);
syndrome_o[5] = ^(data_i & 64'h41F7BB56D5525488);
syndrome_o[6] = ^(data_i & 64'h81FBDDA769A46910);
// Syndrome calculation
assign syndrome_o[0] = ^(data_i & 64'h0303FFF800007FFF);
assign syndrome_o[1] = ^(data_i & 64'h057C1FF801FF801F);
assign syndrome_o[2] = ^(data_i & 64'h09BDE1F87E0781E1);
assign syndrome_o[3] = ^(data_i & 64'h11DEEE3B8E388E22);
assign syndrome_o[4] = ^(data_i & 64'h21EF76CDB2C93244);
assign syndrome_o[5] = ^(data_i & 64'h41F7BB56D5525488);
assign syndrome_o[6] = ^(data_i & 64'h81FBDDA769A46910);
// Corrected output calculation
assign data_o[0] = (syndrome_o == 7'h7) ^ data_i[0];
assign data_o[1] = (syndrome_o == 7'hb) ^ data_i[1];
assign data_o[2] = (syndrome_o == 7'h13) ^ data_i[2];
assign data_o[3] = (syndrome_o == 7'h23) ^ data_i[3];
assign data_o[4] = (syndrome_o == 7'h43) ^ data_i[4];
assign data_o[5] = (syndrome_o == 7'hd) ^ data_i[5];
assign data_o[6] = (syndrome_o == 7'h15) ^ data_i[6];
assign data_o[7] = (syndrome_o == 7'h25) ^ data_i[7];
assign data_o[8] = (syndrome_o == 7'h45) ^ data_i[8];
assign data_o[9] = (syndrome_o == 7'h19) ^ data_i[9];
assign data_o[10] = (syndrome_o == 7'h29) ^ data_i[10];
assign data_o[11] = (syndrome_o == 7'h49) ^ data_i[11];
assign data_o[12] = (syndrome_o == 7'h31) ^ data_i[12];
assign data_o[13] = (syndrome_o == 7'h51) ^ data_i[13];
assign data_o[14] = (syndrome_o == 7'h61) ^ data_i[14];
assign data_o[15] = (syndrome_o == 7'he) ^ data_i[15];
assign data_o[16] = (syndrome_o == 7'h16) ^ data_i[16];
assign data_o[17] = (syndrome_o == 7'h26) ^ data_i[17];
assign data_o[18] = (syndrome_o == 7'h46) ^ data_i[18];
assign data_o[19] = (syndrome_o == 7'h1a) ^ data_i[19];
assign data_o[20] = (syndrome_o == 7'h2a) ^ data_i[20];
assign data_o[21] = (syndrome_o == 7'h4a) ^ data_i[21];
assign data_o[22] = (syndrome_o == 7'h32) ^ data_i[22];
assign data_o[23] = (syndrome_o == 7'h52) ^ data_i[23];
assign data_o[24] = (syndrome_o == 7'h62) ^ data_i[24];
assign data_o[25] = (syndrome_o == 7'h1c) ^ data_i[25];
assign data_o[26] = (syndrome_o == 7'h2c) ^ data_i[26];
assign data_o[27] = (syndrome_o == 7'h4c) ^ data_i[27];
assign data_o[28] = (syndrome_o == 7'h34) ^ data_i[28];
assign data_o[29] = (syndrome_o == 7'h54) ^ data_i[29];
assign data_o[30] = (syndrome_o == 7'h64) ^ data_i[30];
assign data_o[31] = (syndrome_o == 7'h38) ^ data_i[31];
assign data_o[32] = (syndrome_o == 7'h58) ^ data_i[32];
assign data_o[33] = (syndrome_o == 7'h68) ^ data_i[33];
assign data_o[34] = (syndrome_o == 7'h70) ^ data_i[34];
assign data_o[35] = (syndrome_o == 7'h1f) ^ data_i[35];
assign data_o[36] = (syndrome_o == 7'h2f) ^ data_i[36];
assign data_o[37] = (syndrome_o == 7'h4f) ^ data_i[37];
assign data_o[38] = (syndrome_o == 7'h37) ^ data_i[38];
assign data_o[39] = (syndrome_o == 7'h57) ^ data_i[39];
assign data_o[40] = (syndrome_o == 7'h67) ^ data_i[40];
assign data_o[41] = (syndrome_o == 7'h3b) ^ data_i[41];
assign data_o[42] = (syndrome_o == 7'h5b) ^ data_i[42];
assign data_o[43] = (syndrome_o == 7'h6b) ^ data_i[43];
assign data_o[44] = (syndrome_o == 7'h73) ^ data_i[44];
assign data_o[45] = (syndrome_o == 7'h3d) ^ data_i[45];
assign data_o[46] = (syndrome_o == 7'h5d) ^ data_i[46];
assign data_o[47] = (syndrome_o == 7'h6d) ^ data_i[47];
assign data_o[48] = (syndrome_o == 7'h75) ^ data_i[48];
assign data_o[49] = (syndrome_o == 7'h79) ^ data_i[49];
assign data_o[50] = (syndrome_o == 7'h3e) ^ data_i[50];
assign data_o[51] = (syndrome_o == 7'h5e) ^ data_i[51];
assign data_o[52] = (syndrome_o == 7'h6e) ^ data_i[52];
assign data_o[53] = (syndrome_o == 7'h76) ^ data_i[53];
assign data_o[54] = (syndrome_o == 7'h7a) ^ data_i[54];
assign data_o[55] = (syndrome_o == 7'h7c) ^ data_i[55];
assign data_o[56] = (syndrome_o == 7'h7f) ^ data_i[56];
// err_o calc. bit0: single error, bit1: double error
assign single_error = ^syndrome_o;
assign err_o[0] = single_error;
assign err_o[1] = ~single_error & (|syndrome_o);
// Corrected output calculation
data_o[0] = (syndrome_o == 7'h7) ^ data_i[0];
data_o[1] = (syndrome_o == 7'hb) ^ data_i[1];
data_o[2] = (syndrome_o == 7'h13) ^ data_i[2];
data_o[3] = (syndrome_o == 7'h23) ^ data_i[3];
data_o[4] = (syndrome_o == 7'h43) ^ data_i[4];
data_o[5] = (syndrome_o == 7'hd) ^ data_i[5];
data_o[6] = (syndrome_o == 7'h15) ^ data_i[6];
data_o[7] = (syndrome_o == 7'h25) ^ data_i[7];
data_o[8] = (syndrome_o == 7'h45) ^ data_i[8];
data_o[9] = (syndrome_o == 7'h19) ^ data_i[9];
data_o[10] = (syndrome_o == 7'h29) ^ data_i[10];
data_o[11] = (syndrome_o == 7'h49) ^ data_i[11];
data_o[12] = (syndrome_o == 7'h31) ^ data_i[12];
data_o[13] = (syndrome_o == 7'h51) ^ data_i[13];
data_o[14] = (syndrome_o == 7'h61) ^ data_i[14];
data_o[15] = (syndrome_o == 7'he) ^ data_i[15];
data_o[16] = (syndrome_o == 7'h16) ^ data_i[16];
data_o[17] = (syndrome_o == 7'h26) ^ data_i[17];
data_o[18] = (syndrome_o == 7'h46) ^ data_i[18];
data_o[19] = (syndrome_o == 7'h1a) ^ data_i[19];
data_o[20] = (syndrome_o == 7'h2a) ^ data_i[20];
data_o[21] = (syndrome_o == 7'h4a) ^ data_i[21];
data_o[22] = (syndrome_o == 7'h32) ^ data_i[22];
data_o[23] = (syndrome_o == 7'h52) ^ data_i[23];
data_o[24] = (syndrome_o == 7'h62) ^ data_i[24];
data_o[25] = (syndrome_o == 7'h1c) ^ data_i[25];
data_o[26] = (syndrome_o == 7'h2c) ^ data_i[26];
data_o[27] = (syndrome_o == 7'h4c) ^ data_i[27];
data_o[28] = (syndrome_o == 7'h34) ^ data_i[28];
data_o[29] = (syndrome_o == 7'h54) ^ data_i[29];
data_o[30] = (syndrome_o == 7'h64) ^ data_i[30];
data_o[31] = (syndrome_o == 7'h38) ^ data_i[31];
data_o[32] = (syndrome_o == 7'h58) ^ data_i[32];
data_o[33] = (syndrome_o == 7'h68) ^ data_i[33];
data_o[34] = (syndrome_o == 7'h70) ^ data_i[34];
data_o[35] = (syndrome_o == 7'h1f) ^ data_i[35];
data_o[36] = (syndrome_o == 7'h2f) ^ data_i[36];
data_o[37] = (syndrome_o == 7'h4f) ^ data_i[37];
data_o[38] = (syndrome_o == 7'h37) ^ data_i[38];
data_o[39] = (syndrome_o == 7'h57) ^ data_i[39];
data_o[40] = (syndrome_o == 7'h67) ^ data_i[40];
data_o[41] = (syndrome_o == 7'h3b) ^ data_i[41];
data_o[42] = (syndrome_o == 7'h5b) ^ data_i[42];
data_o[43] = (syndrome_o == 7'h6b) ^ data_i[43];
data_o[44] = (syndrome_o == 7'h73) ^ data_i[44];
data_o[45] = (syndrome_o == 7'h3d) ^ data_i[45];
data_o[46] = (syndrome_o == 7'h5d) ^ data_i[46];
data_o[47] = (syndrome_o == 7'h6d) ^ data_i[47];
data_o[48] = (syndrome_o == 7'h75) ^ data_i[48];
data_o[49] = (syndrome_o == 7'h79) ^ data_i[49];
data_o[50] = (syndrome_o == 7'h3e) ^ data_i[50];
data_o[51] = (syndrome_o == 7'h5e) ^ data_i[51];
data_o[52] = (syndrome_o == 7'h6e) ^ data_i[52];
data_o[53] = (syndrome_o == 7'h76) ^ data_i[53];
data_o[54] = (syndrome_o == 7'h7a) ^ data_i[54];
data_o[55] = (syndrome_o == 7'h7c) ^ data_i[55];
data_o[56] = (syndrome_o == 7'h7f) ^ data_i[56];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = ^syndrome_o;
err_o[1] = ~err_o[0] & (|syndrome_o);
end
endmodule : prim_secded_64_57_dec

160
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_72_64_dec.sv vendored
View file

@ -11,87 +11,85 @@ module prim_secded_72_64_dec (
output logic [1:0] err_o
);
logic single_error;
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^(data_i & 72'h01B9000000001FFFFF);
syndrome_o[1] = ^(data_i & 72'h025E00000FFFE0003F);
syndrome_o[2] = ^(data_i & 72'h0467003FF003E007C1);
syndrome_o[3] = ^(data_i & 72'h08CD0FC0F03C207842);
syndrome_o[4] = ^(data_i & 72'h10B671C711C4438884);
syndrome_o[5] = ^(data_i & 72'h20B5B65926488C9108);
syndrome_o[6] = ^(data_i & 72'h40CBDAAA4A91152210);
syndrome_o[7] = ^(data_i & 72'h807AED348D221A4420);
// Syndrome calculation
assign syndrome_o[0] = ^(data_i & 72'h01B9000000001FFFFF);
assign syndrome_o[1] = ^(data_i & 72'h025E00000FFFE0003F);
assign syndrome_o[2] = ^(data_i & 72'h0467003FF003E007C1);
assign syndrome_o[3] = ^(data_i & 72'h08CD0FC0F03C207842);
assign syndrome_o[4] = ^(data_i & 72'h10B671C711C4438884);
assign syndrome_o[5] = ^(data_i & 72'h20B5B65926488C9108);
assign syndrome_o[6] = ^(data_i & 72'h40CBDAAA4A91152210);
assign syndrome_o[7] = ^(data_i & 72'h807AED348D221A4420);
// Corrected output calculation
assign data_o[0] = (syndrome_o == 8'h7) ^ data_i[0];
assign data_o[1] = (syndrome_o == 8'hb) ^ data_i[1];
assign data_o[2] = (syndrome_o == 8'h13) ^ data_i[2];
assign data_o[3] = (syndrome_o == 8'h23) ^ data_i[3];
assign data_o[4] = (syndrome_o == 8'h43) ^ data_i[4];
assign data_o[5] = (syndrome_o == 8'h83) ^ data_i[5];
assign data_o[6] = (syndrome_o == 8'hd) ^ data_i[6];
assign data_o[7] = (syndrome_o == 8'h15) ^ data_i[7];
assign data_o[8] = (syndrome_o == 8'h25) ^ data_i[8];
assign data_o[9] = (syndrome_o == 8'h45) ^ data_i[9];
assign data_o[10] = (syndrome_o == 8'h85) ^ data_i[10];
assign data_o[11] = (syndrome_o == 8'h19) ^ data_i[11];
assign data_o[12] = (syndrome_o == 8'h29) ^ data_i[12];
assign data_o[13] = (syndrome_o == 8'h49) ^ data_i[13];
assign data_o[14] = (syndrome_o == 8'h89) ^ data_i[14];
assign data_o[15] = (syndrome_o == 8'h31) ^ data_i[15];
assign data_o[16] = (syndrome_o == 8'h51) ^ data_i[16];
assign data_o[17] = (syndrome_o == 8'h91) ^ data_i[17];
assign data_o[18] = (syndrome_o == 8'h61) ^ data_i[18];
assign data_o[19] = (syndrome_o == 8'ha1) ^ data_i[19];
assign data_o[20] = (syndrome_o == 8'hc1) ^ data_i[20];
assign data_o[21] = (syndrome_o == 8'he) ^ data_i[21];
assign data_o[22] = (syndrome_o == 8'h16) ^ data_i[22];
assign data_o[23] = (syndrome_o == 8'h26) ^ data_i[23];
assign data_o[24] = (syndrome_o == 8'h46) ^ data_i[24];
assign data_o[25] = (syndrome_o == 8'h86) ^ data_i[25];
assign data_o[26] = (syndrome_o == 8'h1a) ^ data_i[26];
assign data_o[27] = (syndrome_o == 8'h2a) ^ data_i[27];
assign data_o[28] = (syndrome_o == 8'h4a) ^ data_i[28];
assign data_o[29] = (syndrome_o == 8'h8a) ^ data_i[29];
assign data_o[30] = (syndrome_o == 8'h32) ^ data_i[30];
assign data_o[31] = (syndrome_o == 8'h52) ^ data_i[31];
assign data_o[32] = (syndrome_o == 8'h92) ^ data_i[32];
assign data_o[33] = (syndrome_o == 8'h62) ^ data_i[33];
assign data_o[34] = (syndrome_o == 8'ha2) ^ data_i[34];
assign data_o[35] = (syndrome_o == 8'hc2) ^ data_i[35];
assign data_o[36] = (syndrome_o == 8'h1c) ^ data_i[36];
assign data_o[37] = (syndrome_o == 8'h2c) ^ data_i[37];
assign data_o[38] = (syndrome_o == 8'h4c) ^ data_i[38];
assign data_o[39] = (syndrome_o == 8'h8c) ^ data_i[39];
assign data_o[40] = (syndrome_o == 8'h34) ^ data_i[40];
assign data_o[41] = (syndrome_o == 8'h54) ^ data_i[41];
assign data_o[42] = (syndrome_o == 8'h94) ^ data_i[42];
assign data_o[43] = (syndrome_o == 8'h64) ^ data_i[43];
assign data_o[44] = (syndrome_o == 8'ha4) ^ data_i[44];
assign data_o[45] = (syndrome_o == 8'hc4) ^ data_i[45];
assign data_o[46] = (syndrome_o == 8'h38) ^ data_i[46];
assign data_o[47] = (syndrome_o == 8'h58) ^ data_i[47];
assign data_o[48] = (syndrome_o == 8'h98) ^ data_i[48];
assign data_o[49] = (syndrome_o == 8'h68) ^ data_i[49];
assign data_o[50] = (syndrome_o == 8'ha8) ^ data_i[50];
assign data_o[51] = (syndrome_o == 8'hc8) ^ data_i[51];
assign data_o[52] = (syndrome_o == 8'h70) ^ data_i[52];
assign data_o[53] = (syndrome_o == 8'hb0) ^ data_i[53];
assign data_o[54] = (syndrome_o == 8'hd0) ^ data_i[54];
assign data_o[55] = (syndrome_o == 8'he0) ^ data_i[55];
assign data_o[56] = (syndrome_o == 8'h6d) ^ data_i[56];
assign data_o[57] = (syndrome_o == 8'hd6) ^ data_i[57];
assign data_o[58] = (syndrome_o == 8'h3e) ^ data_i[58];
assign data_o[59] = (syndrome_o == 8'hcb) ^ data_i[59];
assign data_o[60] = (syndrome_o == 8'hb3) ^ data_i[60];
assign data_o[61] = (syndrome_o == 8'hb5) ^ data_i[61];
assign data_o[62] = (syndrome_o == 8'hce) ^ data_i[62];
assign data_o[63] = (syndrome_o == 8'h79) ^ data_i[63];
// err_o calc. bit0: single error, bit1: double error
assign single_error = ^syndrome_o;
assign err_o[0] = single_error;
assign err_o[1] = ~single_error & (|syndrome_o);
// Corrected output calculation
data_o[0] = (syndrome_o == 8'h7) ^ data_i[0];
data_o[1] = (syndrome_o == 8'hb) ^ data_i[1];
data_o[2] = (syndrome_o == 8'h13) ^ data_i[2];
data_o[3] = (syndrome_o == 8'h23) ^ data_i[3];
data_o[4] = (syndrome_o == 8'h43) ^ data_i[4];
data_o[5] = (syndrome_o == 8'h83) ^ data_i[5];
data_o[6] = (syndrome_o == 8'hd) ^ data_i[6];
data_o[7] = (syndrome_o == 8'h15) ^ data_i[7];
data_o[8] = (syndrome_o == 8'h25) ^ data_i[8];
data_o[9] = (syndrome_o == 8'h45) ^ data_i[9];
data_o[10] = (syndrome_o == 8'h85) ^ data_i[10];
data_o[11] = (syndrome_o == 8'h19) ^ data_i[11];
data_o[12] = (syndrome_o == 8'h29) ^ data_i[12];
data_o[13] = (syndrome_o == 8'h49) ^ data_i[13];
data_o[14] = (syndrome_o == 8'h89) ^ data_i[14];
data_o[15] = (syndrome_o == 8'h31) ^ data_i[15];
data_o[16] = (syndrome_o == 8'h51) ^ data_i[16];
data_o[17] = (syndrome_o == 8'h91) ^ data_i[17];
data_o[18] = (syndrome_o == 8'h61) ^ data_i[18];
data_o[19] = (syndrome_o == 8'ha1) ^ data_i[19];
data_o[20] = (syndrome_o == 8'hc1) ^ data_i[20];
data_o[21] = (syndrome_o == 8'he) ^ data_i[21];
data_o[22] = (syndrome_o == 8'h16) ^ data_i[22];
data_o[23] = (syndrome_o == 8'h26) ^ data_i[23];
data_o[24] = (syndrome_o == 8'h46) ^ data_i[24];
data_o[25] = (syndrome_o == 8'h86) ^ data_i[25];
data_o[26] = (syndrome_o == 8'h1a) ^ data_i[26];
data_o[27] = (syndrome_o == 8'h2a) ^ data_i[27];
data_o[28] = (syndrome_o == 8'h4a) ^ data_i[28];
data_o[29] = (syndrome_o == 8'h8a) ^ data_i[29];
data_o[30] = (syndrome_o == 8'h32) ^ data_i[30];
data_o[31] = (syndrome_o == 8'h52) ^ data_i[31];
data_o[32] = (syndrome_o == 8'h92) ^ data_i[32];
data_o[33] = (syndrome_o == 8'h62) ^ data_i[33];
data_o[34] = (syndrome_o == 8'ha2) ^ data_i[34];
data_o[35] = (syndrome_o == 8'hc2) ^ data_i[35];
data_o[36] = (syndrome_o == 8'h1c) ^ data_i[36];
data_o[37] = (syndrome_o == 8'h2c) ^ data_i[37];
data_o[38] = (syndrome_o == 8'h4c) ^ data_i[38];
data_o[39] = (syndrome_o == 8'h8c) ^ data_i[39];
data_o[40] = (syndrome_o == 8'h34) ^ data_i[40];
data_o[41] = (syndrome_o == 8'h54) ^ data_i[41];
data_o[42] = (syndrome_o == 8'h94) ^ data_i[42];
data_o[43] = (syndrome_o == 8'h64) ^ data_i[43];
data_o[44] = (syndrome_o == 8'ha4) ^ data_i[44];
data_o[45] = (syndrome_o == 8'hc4) ^ data_i[45];
data_o[46] = (syndrome_o == 8'h38) ^ data_i[46];
data_o[47] = (syndrome_o == 8'h58) ^ data_i[47];
data_o[48] = (syndrome_o == 8'h98) ^ data_i[48];
data_o[49] = (syndrome_o == 8'h68) ^ data_i[49];
data_o[50] = (syndrome_o == 8'ha8) ^ data_i[50];
data_o[51] = (syndrome_o == 8'hc8) ^ data_i[51];
data_o[52] = (syndrome_o == 8'h70) ^ data_i[52];
data_o[53] = (syndrome_o == 8'hb0) ^ data_i[53];
data_o[54] = (syndrome_o == 8'hd0) ^ data_i[54];
data_o[55] = (syndrome_o == 8'he0) ^ data_i[55];
data_o[56] = (syndrome_o == 8'h6d) ^ data_i[56];
data_o[57] = (syndrome_o == 8'hd6) ^ data_i[57];
data_o[58] = (syndrome_o == 8'h3e) ^ data_i[58];
data_o[59] = (syndrome_o == 8'hcb) ^ data_i[59];
data_o[60] = (syndrome_o == 8'hb3) ^ data_i[60];
data_o[61] = (syndrome_o == 8'hb5) ^ data_i[61];
data_o[62] = (syndrome_o == 8'hce) ^ data_i[62];
data_o[63] = (syndrome_o == 8'h79) ^ data_i[63];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = ^syndrome_o;
err_o[1] = ~err_o[0] & (|syndrome_o);
end
endmodule : prim_secded_72_64_dec

58
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_hamming_22_16_dec.sv vendored
View file

@ -11,35 +11,35 @@ module prim_secded_hamming_22_16_dec (
output logic [1:0] err_o
);
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^(data_i & 22'h01AD5B);
syndrome_o[1] = ^(data_i & 22'h02366D);
syndrome_o[2] = ^(data_i & 22'h04C78E);
syndrome_o[3] = ^(data_i & 22'h0807F0);
syndrome_o[4] = ^(data_i & 22'h10F800);
syndrome_o[5] = ^(data_i & 22'h3FFFFF);
// Syndrome calculation
assign syndrome_o[0] = ^(data_i & 22'h01AD5B);
assign syndrome_o[1] = ^(data_i & 22'h02366D);
assign syndrome_o[2] = ^(data_i & 22'h04C78E);
assign syndrome_o[3] = ^(data_i & 22'h0807F0);
assign syndrome_o[4] = ^(data_i & 22'h10F800);
assign syndrome_o[5] = ^(data_i & 22'h3FFFFF);
// Corrected output calculation
assign data_o[0] = (syndrome_o == 6'h23) ^ data_i[0];
assign data_o[1] = (syndrome_o == 6'h25) ^ data_i[1];
assign data_o[2] = (syndrome_o == 6'h26) ^ data_i[2];
assign data_o[3] = (syndrome_o == 6'h27) ^ data_i[3];
assign data_o[4] = (syndrome_o == 6'h29) ^ data_i[4];
assign data_o[5] = (syndrome_o == 6'h2a) ^ data_i[5];
assign data_o[6] = (syndrome_o == 6'h2b) ^ data_i[6];
assign data_o[7] = (syndrome_o == 6'h2c) ^ data_i[7];
assign data_o[8] = (syndrome_o == 6'h2d) ^ data_i[8];
assign data_o[9] = (syndrome_o == 6'h2e) ^ data_i[9];
assign data_o[10] = (syndrome_o == 6'h2f) ^ data_i[10];
assign data_o[11] = (syndrome_o == 6'h31) ^ data_i[11];
assign data_o[12] = (syndrome_o == 6'h32) ^ data_i[12];
assign data_o[13] = (syndrome_o == 6'h33) ^ data_i[13];
assign data_o[14] = (syndrome_o == 6'h34) ^ data_i[14];
assign data_o[15] = (syndrome_o == 6'h35) ^ data_i[15];
// err_o calc. bit0: single error, bit1: double error
assign err_o[0] = syndrome_o[5];
assign err_o[1] = |syndrome_o[4:0] & ~syndrome_o[5];
// Corrected output calculation
data_o[0] = (syndrome_o == 6'h23) ^ data_i[0];
data_o[1] = (syndrome_o == 6'h25) ^ data_i[1];
data_o[2] = (syndrome_o == 6'h26) ^ data_i[2];
data_o[3] = (syndrome_o == 6'h27) ^ data_i[3];
data_o[4] = (syndrome_o == 6'h29) ^ data_i[4];
data_o[5] = (syndrome_o == 6'h2a) ^ data_i[5];
data_o[6] = (syndrome_o == 6'h2b) ^ data_i[6];
data_o[7] = (syndrome_o == 6'h2c) ^ data_i[7];
data_o[8] = (syndrome_o == 6'h2d) ^ data_i[8];
data_o[9] = (syndrome_o == 6'h2e) ^ data_i[9];
data_o[10] = (syndrome_o == 6'h2f) ^ data_i[10];
data_o[11] = (syndrome_o == 6'h31) ^ data_i[11];
data_o[12] = (syndrome_o == 6'h32) ^ data_i[12];
data_o[13] = (syndrome_o == 6'h33) ^ data_i[13];
data_o[14] = (syndrome_o == 6'h34) ^ data_i[14];
data_o[15] = (syndrome_o == 6'h35) ^ data_i[15];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = syndrome_o[5];
err_o[1] = |syndrome_o[4:0] & ~syndrome_o[5];
end
endmodule : prim_secded_hamming_22_16_dec

92
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_hamming_39_32_dec.sv vendored
View file

@ -11,52 +11,52 @@ module prim_secded_hamming_39_32_dec (
output logic [1:0] err_o
);
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^(data_i & 39'h0156AAAD5B);
syndrome_o[1] = ^(data_i & 39'h029B33366D);
syndrome_o[2] = ^(data_i & 39'h04E3C3C78E);
syndrome_o[3] = ^(data_i & 39'h0803FC07F0);
syndrome_o[4] = ^(data_i & 39'h1003FFF800);
syndrome_o[5] = ^(data_i & 39'h20FC000000);
syndrome_o[6] = ^(data_i & 39'h7FFFFFFFFF);
// Syndrome calculation
assign syndrome_o[0] = ^(data_i & 39'h0156AAAD5B);
assign syndrome_o[1] = ^(data_i & 39'h029B33366D);
assign syndrome_o[2] = ^(data_i & 39'h04E3C3C78E);
assign syndrome_o[3] = ^(data_i & 39'h0803FC07F0);
assign syndrome_o[4] = ^(data_i & 39'h1003FFF800);
assign syndrome_o[5] = ^(data_i & 39'h20FC000000);
assign syndrome_o[6] = ^(data_i & 39'h7FFFFFFFFF);
// Corrected output calculation
assign data_o[0] = (syndrome_o == 7'h43) ^ data_i[0];
assign data_o[1] = (syndrome_o == 7'h45) ^ data_i[1];
assign data_o[2] = (syndrome_o == 7'h46) ^ data_i[2];
assign data_o[3] = (syndrome_o == 7'h47) ^ data_i[3];
assign data_o[4] = (syndrome_o == 7'h49) ^ data_i[4];
assign data_o[5] = (syndrome_o == 7'h4a) ^ data_i[5];
assign data_o[6] = (syndrome_o == 7'h4b) ^ data_i[6];
assign data_o[7] = (syndrome_o == 7'h4c) ^ data_i[7];
assign data_o[8] = (syndrome_o == 7'h4d) ^ data_i[8];
assign data_o[9] = (syndrome_o == 7'h4e) ^ data_i[9];
assign data_o[10] = (syndrome_o == 7'h4f) ^ data_i[10];
assign data_o[11] = (syndrome_o == 7'h51) ^ data_i[11];
assign data_o[12] = (syndrome_o == 7'h52) ^ data_i[12];
assign data_o[13] = (syndrome_o == 7'h53) ^ data_i[13];
assign data_o[14] = (syndrome_o == 7'h54) ^ data_i[14];
assign data_o[15] = (syndrome_o == 7'h55) ^ data_i[15];
assign data_o[16] = (syndrome_o == 7'h56) ^ data_i[16];
assign data_o[17] = (syndrome_o == 7'h57) ^ data_i[17];
assign data_o[18] = (syndrome_o == 7'h58) ^ data_i[18];
assign data_o[19] = (syndrome_o == 7'h59) ^ data_i[19];
assign data_o[20] = (syndrome_o == 7'h5a) ^ data_i[20];
assign data_o[21] = (syndrome_o == 7'h5b) ^ data_i[21];
assign data_o[22] = (syndrome_o == 7'h5c) ^ data_i[22];
assign data_o[23] = (syndrome_o == 7'h5d) ^ data_i[23];
assign data_o[24] = (syndrome_o == 7'h5e) ^ data_i[24];
assign data_o[25] = (syndrome_o == 7'h5f) ^ data_i[25];
assign data_o[26] = (syndrome_o == 7'h61) ^ data_i[26];
assign data_o[27] = (syndrome_o == 7'h62) ^ data_i[27];
assign data_o[28] = (syndrome_o == 7'h63) ^ data_i[28];
assign data_o[29] = (syndrome_o == 7'h64) ^ data_i[29];
assign data_o[30] = (syndrome_o == 7'h65) ^ data_i[30];
assign data_o[31] = (syndrome_o == 7'h66) ^ data_i[31];
// err_o calc. bit0: single error, bit1: double error
assign err_o[0] = syndrome_o[6];
assign err_o[1] = |syndrome_o[5:0] & ~syndrome_o[6];
// Corrected output calculation
data_o[0] = (syndrome_o == 7'h43) ^ data_i[0];
data_o[1] = (syndrome_o == 7'h45) ^ data_i[1];
data_o[2] = (syndrome_o == 7'h46) ^ data_i[2];
data_o[3] = (syndrome_o == 7'h47) ^ data_i[3];
data_o[4] = (syndrome_o == 7'h49) ^ data_i[4];
data_o[5] = (syndrome_o == 7'h4a) ^ data_i[5];
data_o[6] = (syndrome_o == 7'h4b) ^ data_i[6];
data_o[7] = (syndrome_o == 7'h4c) ^ data_i[7];
data_o[8] = (syndrome_o == 7'h4d) ^ data_i[8];
data_o[9] = (syndrome_o == 7'h4e) ^ data_i[9];
data_o[10] = (syndrome_o == 7'h4f) ^ data_i[10];
data_o[11] = (syndrome_o == 7'h51) ^ data_i[11];
data_o[12] = (syndrome_o == 7'h52) ^ data_i[12];
data_o[13] = (syndrome_o == 7'h53) ^ data_i[13];
data_o[14] = (syndrome_o == 7'h54) ^ data_i[14];
data_o[15] = (syndrome_o == 7'h55) ^ data_i[15];
data_o[16] = (syndrome_o == 7'h56) ^ data_i[16];
data_o[17] = (syndrome_o == 7'h57) ^ data_i[17];
data_o[18] = (syndrome_o == 7'h58) ^ data_i[18];
data_o[19] = (syndrome_o == 7'h59) ^ data_i[19];
data_o[20] = (syndrome_o == 7'h5a) ^ data_i[20];
data_o[21] = (syndrome_o == 7'h5b) ^ data_i[21];
data_o[22] = (syndrome_o == 7'h5c) ^ data_i[22];
data_o[23] = (syndrome_o == 7'h5d) ^ data_i[23];
data_o[24] = (syndrome_o == 7'h5e) ^ data_i[24];
data_o[25] = (syndrome_o == 7'h5f) ^ data_i[25];
data_o[26] = (syndrome_o == 7'h61) ^ data_i[26];
data_o[27] = (syndrome_o == 7'h62) ^ data_i[27];
data_o[28] = (syndrome_o == 7'h63) ^ data_i[28];
data_o[29] = (syndrome_o == 7'h64) ^ data_i[29];
data_o[30] = (syndrome_o == 7'h65) ^ data_i[30];
data_o[31] = (syndrome_o == 7'h66) ^ data_i[31];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = syndrome_o[6];
err_o[1] = |syndrome_o[5:0] & ~syndrome_o[6];
end
endmodule : prim_secded_hamming_39_32_dec

158
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_hamming_72_64_dec.sv vendored
View file

@ -11,85 +11,85 @@ module prim_secded_hamming_72_64_dec (
output logic [1:0] err_o
);
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^(data_i & 72'h01AB55555556AAAD5B);
syndrome_o[1] = ^(data_i & 72'h02CD9999999B33366D);
syndrome_o[2] = ^(data_i & 72'h04F1E1E1E1E3C3C78E);
syndrome_o[3] = ^(data_i & 72'h0801FE01FE03FC07F0);
syndrome_o[4] = ^(data_i & 72'h1001FFFE0003FFF800);
syndrome_o[5] = ^(data_i & 72'h2001FFFFFFFC000000);
syndrome_o[6] = ^(data_i & 72'h40FE00000000000000);
syndrome_o[7] = ^(data_i & 72'hFFFFFFFFFFFFFFFFFF);
// Syndrome calculation
assign syndrome_o[0] = ^(data_i & 72'h01AB55555556AAAD5B);
assign syndrome_o[1] = ^(data_i & 72'h02CD9999999B33366D);
assign syndrome_o[2] = ^(data_i & 72'h04F1E1E1E1E3C3C78E);
assign syndrome_o[3] = ^(data_i & 72'h0801FE01FE03FC07F0);
assign syndrome_o[4] = ^(data_i & 72'h1001FFFE0003FFF800);
assign syndrome_o[5] = ^(data_i & 72'h2001FFFFFFFC000000);
assign syndrome_o[6] = ^(data_i & 72'h40FE00000000000000);
assign syndrome_o[7] = ^(data_i & 72'hFFFFFFFFFFFFFFFFFF);
// Corrected output calculation
assign data_o[0] = (syndrome_o == 8'h83) ^ data_i[0];
assign data_o[1] = (syndrome_o == 8'h85) ^ data_i[1];
assign data_o[2] = (syndrome_o == 8'h86) ^ data_i[2];
assign data_o[3] = (syndrome_o == 8'h87) ^ data_i[3];
assign data_o[4] = (syndrome_o == 8'h89) ^ data_i[4];
assign data_o[5] = (syndrome_o == 8'h8a) ^ data_i[5];
assign data_o[6] = (syndrome_o == 8'h8b) ^ data_i[6];
assign data_o[7] = (syndrome_o == 8'h8c) ^ data_i[7];
assign data_o[8] = (syndrome_o == 8'h8d) ^ data_i[8];
assign data_o[9] = (syndrome_o == 8'h8e) ^ data_i[9];
assign data_o[10] = (syndrome_o == 8'h8f) ^ data_i[10];
assign data_o[11] = (syndrome_o == 8'h91) ^ data_i[11];
assign data_o[12] = (syndrome_o == 8'h92) ^ data_i[12];
assign data_o[13] = (syndrome_o == 8'h93) ^ data_i[13];
assign data_o[14] = (syndrome_o == 8'h94) ^ data_i[14];
assign data_o[15] = (syndrome_o == 8'h95) ^ data_i[15];
assign data_o[16] = (syndrome_o == 8'h96) ^ data_i[16];
assign data_o[17] = (syndrome_o == 8'h97) ^ data_i[17];
assign data_o[18] = (syndrome_o == 8'h98) ^ data_i[18];
assign data_o[19] = (syndrome_o == 8'h99) ^ data_i[19];
assign data_o[20] = (syndrome_o == 8'h9a) ^ data_i[20];
assign data_o[21] = (syndrome_o == 8'h9b) ^ data_i[21];
assign data_o[22] = (syndrome_o == 8'h9c) ^ data_i[22];
assign data_o[23] = (syndrome_o == 8'h9d) ^ data_i[23];
assign data_o[24] = (syndrome_o == 8'h9e) ^ data_i[24];
assign data_o[25] = (syndrome_o == 8'h9f) ^ data_i[25];
assign data_o[26] = (syndrome_o == 8'ha1) ^ data_i[26];
assign data_o[27] = (syndrome_o == 8'ha2) ^ data_i[27];
assign data_o[28] = (syndrome_o == 8'ha3) ^ data_i[28];
assign data_o[29] = (syndrome_o == 8'ha4) ^ data_i[29];
assign data_o[30] = (syndrome_o == 8'ha5) ^ data_i[30];
assign data_o[31] = (syndrome_o == 8'ha6) ^ data_i[31];
assign data_o[32] = (syndrome_o == 8'ha7) ^ data_i[32];
assign data_o[33] = (syndrome_o == 8'ha8) ^ data_i[33];
assign data_o[34] = (syndrome_o == 8'ha9) ^ data_i[34];
assign data_o[35] = (syndrome_o == 8'haa) ^ data_i[35];
assign data_o[36] = (syndrome_o == 8'hab) ^ data_i[36];
assign data_o[37] = (syndrome_o == 8'hac) ^ data_i[37];
assign data_o[38] = (syndrome_o == 8'had) ^ data_i[38];
assign data_o[39] = (syndrome_o == 8'hae) ^ data_i[39];
assign data_o[40] = (syndrome_o == 8'haf) ^ data_i[40];
assign data_o[41] = (syndrome_o == 8'hb0) ^ data_i[41];
assign data_o[42] = (syndrome_o == 8'hb1) ^ data_i[42];
assign data_o[43] = (syndrome_o == 8'hb2) ^ data_i[43];
assign data_o[44] = (syndrome_o == 8'hb3) ^ data_i[44];
assign data_o[45] = (syndrome_o == 8'hb4) ^ data_i[45];
assign data_o[46] = (syndrome_o == 8'hb5) ^ data_i[46];
assign data_o[47] = (syndrome_o == 8'hb6) ^ data_i[47];
assign data_o[48] = (syndrome_o == 8'hb7) ^ data_i[48];
assign data_o[49] = (syndrome_o == 8'hb8) ^ data_i[49];
assign data_o[50] = (syndrome_o == 8'hb9) ^ data_i[50];
assign data_o[51] = (syndrome_o == 8'hba) ^ data_i[51];
assign data_o[52] = (syndrome_o == 8'hbb) ^ data_i[52];
assign data_o[53] = (syndrome_o == 8'hbc) ^ data_i[53];
assign data_o[54] = (syndrome_o == 8'hbd) ^ data_i[54];
assign data_o[55] = (syndrome_o == 8'hbe) ^ data_i[55];
assign data_o[56] = (syndrome_o == 8'hbf) ^ data_i[56];
assign data_o[57] = (syndrome_o == 8'hc1) ^ data_i[57];
assign data_o[58] = (syndrome_o == 8'hc2) ^ data_i[58];
assign data_o[59] = (syndrome_o == 8'hc3) ^ data_i[59];
assign data_o[60] = (syndrome_o == 8'hc4) ^ data_i[60];
assign data_o[61] = (syndrome_o == 8'hc5) ^ data_i[61];
assign data_o[62] = (syndrome_o == 8'hc6) ^ data_i[62];
assign data_o[63] = (syndrome_o == 8'hc7) ^ data_i[63];
// err_o calc. bit0: single error, bit1: double error
assign err_o[0] = syndrome_o[7];
assign err_o[1] = |syndrome_o[6:0] & ~syndrome_o[7];
// Corrected output calculation
data_o[0] = (syndrome_o == 8'h83) ^ data_i[0];
data_o[1] = (syndrome_o == 8'h85) ^ data_i[1];
data_o[2] = (syndrome_o == 8'h86) ^ data_i[2];
data_o[3] = (syndrome_o == 8'h87) ^ data_i[3];
data_o[4] = (syndrome_o == 8'h89) ^ data_i[4];
data_o[5] = (syndrome_o == 8'h8a) ^ data_i[5];
data_o[6] = (syndrome_o == 8'h8b) ^ data_i[6];
data_o[7] = (syndrome_o == 8'h8c) ^ data_i[7];
data_o[8] = (syndrome_o == 8'h8d) ^ data_i[8];
data_o[9] = (syndrome_o == 8'h8e) ^ data_i[9];
data_o[10] = (syndrome_o == 8'h8f) ^ data_i[10];
data_o[11] = (syndrome_o == 8'h91) ^ data_i[11];
data_o[12] = (syndrome_o == 8'h92) ^ data_i[12];
data_o[13] = (syndrome_o == 8'h93) ^ data_i[13];
data_o[14] = (syndrome_o == 8'h94) ^ data_i[14];
data_o[15] = (syndrome_o == 8'h95) ^ data_i[15];
data_o[16] = (syndrome_o == 8'h96) ^ data_i[16];
data_o[17] = (syndrome_o == 8'h97) ^ data_i[17];
data_o[18] = (syndrome_o == 8'h98) ^ data_i[18];
data_o[19] = (syndrome_o == 8'h99) ^ data_i[19];
data_o[20] = (syndrome_o == 8'h9a) ^ data_i[20];
data_o[21] = (syndrome_o == 8'h9b) ^ data_i[21];
data_o[22] = (syndrome_o == 8'h9c) ^ data_i[22];
data_o[23] = (syndrome_o == 8'h9d) ^ data_i[23];
data_o[24] = (syndrome_o == 8'h9e) ^ data_i[24];
data_o[25] = (syndrome_o == 8'h9f) ^ data_i[25];
data_o[26] = (syndrome_o == 8'ha1) ^ data_i[26];
data_o[27] = (syndrome_o == 8'ha2) ^ data_i[27];
data_o[28] = (syndrome_o == 8'ha3) ^ data_i[28];
data_o[29] = (syndrome_o == 8'ha4) ^ data_i[29];
data_o[30] = (syndrome_o == 8'ha5) ^ data_i[30];
data_o[31] = (syndrome_o == 8'ha6) ^ data_i[31];
data_o[32] = (syndrome_o == 8'ha7) ^ data_i[32];
data_o[33] = (syndrome_o == 8'ha8) ^ data_i[33];
data_o[34] = (syndrome_o == 8'ha9) ^ data_i[34];
data_o[35] = (syndrome_o == 8'haa) ^ data_i[35];
data_o[36] = (syndrome_o == 8'hab) ^ data_i[36];
data_o[37] = (syndrome_o == 8'hac) ^ data_i[37];
data_o[38] = (syndrome_o == 8'had) ^ data_i[38];
data_o[39] = (syndrome_o == 8'hae) ^ data_i[39];
data_o[40] = (syndrome_o == 8'haf) ^ data_i[40];
data_o[41] = (syndrome_o == 8'hb0) ^ data_i[41];
data_o[42] = (syndrome_o == 8'hb1) ^ data_i[42];
data_o[43] = (syndrome_o == 8'hb2) ^ data_i[43];
data_o[44] = (syndrome_o == 8'hb3) ^ data_i[44];
data_o[45] = (syndrome_o == 8'hb4) ^ data_i[45];
data_o[46] = (syndrome_o == 8'hb5) ^ data_i[46];
data_o[47] = (syndrome_o == 8'hb6) ^ data_i[47];
data_o[48] = (syndrome_o == 8'hb7) ^ data_i[48];
data_o[49] = (syndrome_o == 8'hb8) ^ data_i[49];
data_o[50] = (syndrome_o == 8'hb9) ^ data_i[50];
data_o[51] = (syndrome_o == 8'hba) ^ data_i[51];
data_o[52] = (syndrome_o == 8'hbb) ^ data_i[52];
data_o[53] = (syndrome_o == 8'hbc) ^ data_i[53];
data_o[54] = (syndrome_o == 8'hbd) ^ data_i[54];
data_o[55] = (syndrome_o == 8'hbe) ^ data_i[55];
data_o[56] = (syndrome_o == 8'hbf) ^ data_i[56];
data_o[57] = (syndrome_o == 8'hc1) ^ data_i[57];
data_o[58] = (syndrome_o == 8'hc2) ^ data_i[58];
data_o[59] = (syndrome_o == 8'hc3) ^ data_i[59];
data_o[60] = (syndrome_o == 8'hc4) ^ data_i[60];
data_o[61] = (syndrome_o == 8'hc5) ^ data_i[61];
data_o[62] = (syndrome_o == 8'hc6) ^ data_i[62];
data_o[63] = (syndrome_o == 8'hc7) ^ data_i[63];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = syndrome_o[7];
err_o[1] = |syndrome_o[6:0] & ~syndrome_o[7];
end
endmodule : prim_secded_hamming_72_64_dec

166
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_hamming_76_68_dec.sv vendored
View file

@ -11,89 +11,89 @@ module prim_secded_hamming_76_68_dec (
output logic [1:0] err_o
);
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^(data_i & 76'h01AAB55555556AAAD5B);
syndrome_o[1] = ^(data_i & 76'h02CCD9999999B33366D);
syndrome_o[2] = ^(data_i & 76'h040F1E1E1E1E3C3C78E);
syndrome_o[3] = ^(data_i & 76'h08F01FE01FE03FC07F0);
syndrome_o[4] = ^(data_i & 76'h10001FFFE0003FFF800);
syndrome_o[5] = ^(data_i & 76'h20001FFFFFFFC000000);
syndrome_o[6] = ^(data_i & 76'h40FFE00000000000000);
syndrome_o[7] = ^(data_i & 76'hFFFFFFFFFFFFFFFFFFF);
// Syndrome calculation
assign syndrome_o[0] = ^(data_i & 76'h01AAB55555556AAAD5B);
assign syndrome_o[1] = ^(data_i & 76'h02CCD9999999B33366D);
assign syndrome_o[2] = ^(data_i & 76'h040F1E1E1E1E3C3C78E);
assign syndrome_o[3] = ^(data_i & 76'h08F01FE01FE03FC07F0);
assign syndrome_o[4] = ^(data_i & 76'h10001FFFE0003FFF800);
assign syndrome_o[5] = ^(data_i & 76'h20001FFFFFFFC000000);
assign syndrome_o[6] = ^(data_i & 76'h40FFE00000000000000);
assign syndrome_o[7] = ^(data_i & 76'hFFFFFFFFFFFFFFFFFFF);
// Corrected output calculation
assign data_o[0] = (syndrome_o == 8'h83) ^ data_i[0];
assign data_o[1] = (syndrome_o == 8'h85) ^ data_i[1];
assign data_o[2] = (syndrome_o == 8'h86) ^ data_i[2];
assign data_o[3] = (syndrome_o == 8'h87) ^ data_i[3];
assign data_o[4] = (syndrome_o == 8'h89) ^ data_i[4];
assign data_o[5] = (syndrome_o == 8'h8a) ^ data_i[5];
assign data_o[6] = (syndrome_o == 8'h8b) ^ data_i[6];
assign data_o[7] = (syndrome_o == 8'h8c) ^ data_i[7];
assign data_o[8] = (syndrome_o == 8'h8d) ^ data_i[8];
assign data_o[9] = (syndrome_o == 8'h8e) ^ data_i[9];
assign data_o[10] = (syndrome_o == 8'h8f) ^ data_i[10];
assign data_o[11] = (syndrome_o == 8'h91) ^ data_i[11];
assign data_o[12] = (syndrome_o == 8'h92) ^ data_i[12];
assign data_o[13] = (syndrome_o == 8'h93) ^ data_i[13];
assign data_o[14] = (syndrome_o == 8'h94) ^ data_i[14];
assign data_o[15] = (syndrome_o == 8'h95) ^ data_i[15];
assign data_o[16] = (syndrome_o == 8'h96) ^ data_i[16];
assign data_o[17] = (syndrome_o == 8'h97) ^ data_i[17];
assign data_o[18] = (syndrome_o == 8'h98) ^ data_i[18];
assign data_o[19] = (syndrome_o == 8'h99) ^ data_i[19];
assign data_o[20] = (syndrome_o == 8'h9a) ^ data_i[20];
assign data_o[21] = (syndrome_o == 8'h9b) ^ data_i[21];
assign data_o[22] = (syndrome_o == 8'h9c) ^ data_i[22];
assign data_o[23] = (syndrome_o == 8'h9d) ^ data_i[23];
assign data_o[24] = (syndrome_o == 8'h9e) ^ data_i[24];
assign data_o[25] = (syndrome_o == 8'h9f) ^ data_i[25];
assign data_o[26] = (syndrome_o == 8'ha1) ^ data_i[26];
assign data_o[27] = (syndrome_o == 8'ha2) ^ data_i[27];
assign data_o[28] = (syndrome_o == 8'ha3) ^ data_i[28];
assign data_o[29] = (syndrome_o == 8'ha4) ^ data_i[29];
assign data_o[30] = (syndrome_o == 8'ha5) ^ data_i[30];
assign data_o[31] = (syndrome_o == 8'ha6) ^ data_i[31];
assign data_o[32] = (syndrome_o == 8'ha7) ^ data_i[32];
assign data_o[33] = (syndrome_o == 8'ha8) ^ data_i[33];
assign data_o[34] = (syndrome_o == 8'ha9) ^ data_i[34];
assign data_o[35] = (syndrome_o == 8'haa) ^ data_i[35];
assign data_o[36] = (syndrome_o == 8'hab) ^ data_i[36];
assign data_o[37] = (syndrome_o == 8'hac) ^ data_i[37];
assign data_o[38] = (syndrome_o == 8'had) ^ data_i[38];
assign data_o[39] = (syndrome_o == 8'hae) ^ data_i[39];
assign data_o[40] = (syndrome_o == 8'haf) ^ data_i[40];
assign data_o[41] = (syndrome_o == 8'hb0) ^ data_i[41];
assign data_o[42] = (syndrome_o == 8'hb1) ^ data_i[42];
assign data_o[43] = (syndrome_o == 8'hb2) ^ data_i[43];
assign data_o[44] = (syndrome_o == 8'hb3) ^ data_i[44];
assign data_o[45] = (syndrome_o == 8'hb4) ^ data_i[45];
assign data_o[46] = (syndrome_o == 8'hb5) ^ data_i[46];
assign data_o[47] = (syndrome_o == 8'hb6) ^ data_i[47];
assign data_o[48] = (syndrome_o == 8'hb7) ^ data_i[48];
assign data_o[49] = (syndrome_o == 8'hb8) ^ data_i[49];
assign data_o[50] = (syndrome_o == 8'hb9) ^ data_i[50];
assign data_o[51] = (syndrome_o == 8'hba) ^ data_i[51];
assign data_o[52] = (syndrome_o == 8'hbb) ^ data_i[52];
assign data_o[53] = (syndrome_o == 8'hbc) ^ data_i[53];
assign data_o[54] = (syndrome_o == 8'hbd) ^ data_i[54];
assign data_o[55] = (syndrome_o == 8'hbe) ^ data_i[55];
assign data_o[56] = (syndrome_o == 8'hbf) ^ data_i[56];
assign data_o[57] = (syndrome_o == 8'hc1) ^ data_i[57];
assign data_o[58] = (syndrome_o == 8'hc2) ^ data_i[58];
assign data_o[59] = (syndrome_o == 8'hc3) ^ data_i[59];
assign data_o[60] = (syndrome_o == 8'hc4) ^ data_i[60];
assign data_o[61] = (syndrome_o == 8'hc5) ^ data_i[61];
assign data_o[62] = (syndrome_o == 8'hc6) ^ data_i[62];
assign data_o[63] = (syndrome_o == 8'hc7) ^ data_i[63];
assign data_o[64] = (syndrome_o == 8'hc8) ^ data_i[64];
assign data_o[65] = (syndrome_o == 8'hc9) ^ data_i[65];
assign data_o[66] = (syndrome_o == 8'hca) ^ data_i[66];
assign data_o[67] = (syndrome_o == 8'hcb) ^ data_i[67];
// err_o calc. bit0: single error, bit1: double error
assign err_o[0] = syndrome_o[7];
assign err_o[1] = |syndrome_o[6:0] & ~syndrome_o[7];
// Corrected output calculation
data_o[0] = (syndrome_o == 8'h83) ^ data_i[0];
data_o[1] = (syndrome_o == 8'h85) ^ data_i[1];
data_o[2] = (syndrome_o == 8'h86) ^ data_i[2];
data_o[3] = (syndrome_o == 8'h87) ^ data_i[3];
data_o[4] = (syndrome_o == 8'h89) ^ data_i[4];
data_o[5] = (syndrome_o == 8'h8a) ^ data_i[5];
data_o[6] = (syndrome_o == 8'h8b) ^ data_i[6];
data_o[7] = (syndrome_o == 8'h8c) ^ data_i[7];
data_o[8] = (syndrome_o == 8'h8d) ^ data_i[8];
data_o[9] = (syndrome_o == 8'h8e) ^ data_i[9];
data_o[10] = (syndrome_o == 8'h8f) ^ data_i[10];
data_o[11] = (syndrome_o == 8'h91) ^ data_i[11];
data_o[12] = (syndrome_o == 8'h92) ^ data_i[12];
data_o[13] = (syndrome_o == 8'h93) ^ data_i[13];
data_o[14] = (syndrome_o == 8'h94) ^ data_i[14];
data_o[15] = (syndrome_o == 8'h95) ^ data_i[15];
data_o[16] = (syndrome_o == 8'h96) ^ data_i[16];
data_o[17] = (syndrome_o == 8'h97) ^ data_i[17];
data_o[18] = (syndrome_o == 8'h98) ^ data_i[18];
data_o[19] = (syndrome_o == 8'h99) ^ data_i[19];
data_o[20] = (syndrome_o == 8'h9a) ^ data_i[20];
data_o[21] = (syndrome_o == 8'h9b) ^ data_i[21];
data_o[22] = (syndrome_o == 8'h9c) ^ data_i[22];
data_o[23] = (syndrome_o == 8'h9d) ^ data_i[23];
data_o[24] = (syndrome_o == 8'h9e) ^ data_i[24];
data_o[25] = (syndrome_o == 8'h9f) ^ data_i[25];
data_o[26] = (syndrome_o == 8'ha1) ^ data_i[26];
data_o[27] = (syndrome_o == 8'ha2) ^ data_i[27];
data_o[28] = (syndrome_o == 8'ha3) ^ data_i[28];
data_o[29] = (syndrome_o == 8'ha4) ^ data_i[29];
data_o[30] = (syndrome_o == 8'ha5) ^ data_i[30];
data_o[31] = (syndrome_o == 8'ha6) ^ data_i[31];
data_o[32] = (syndrome_o == 8'ha7) ^ data_i[32];
data_o[33] = (syndrome_o == 8'ha8) ^ data_i[33];
data_o[34] = (syndrome_o == 8'ha9) ^ data_i[34];
data_o[35] = (syndrome_o == 8'haa) ^ data_i[35];
data_o[36] = (syndrome_o == 8'hab) ^ data_i[36];
data_o[37] = (syndrome_o == 8'hac) ^ data_i[37];
data_o[38] = (syndrome_o == 8'had) ^ data_i[38];
data_o[39] = (syndrome_o == 8'hae) ^ data_i[39];
data_o[40] = (syndrome_o == 8'haf) ^ data_i[40];
data_o[41] = (syndrome_o == 8'hb0) ^ data_i[41];
data_o[42] = (syndrome_o == 8'hb1) ^ data_i[42];
data_o[43] = (syndrome_o == 8'hb2) ^ data_i[43];
data_o[44] = (syndrome_o == 8'hb3) ^ data_i[44];
data_o[45] = (syndrome_o == 8'hb4) ^ data_i[45];
data_o[46] = (syndrome_o == 8'hb5) ^ data_i[46];
data_o[47] = (syndrome_o == 8'hb6) ^ data_i[47];
data_o[48] = (syndrome_o == 8'hb7) ^ data_i[48];
data_o[49] = (syndrome_o == 8'hb8) ^ data_i[49];
data_o[50] = (syndrome_o == 8'hb9) ^ data_i[50];
data_o[51] = (syndrome_o == 8'hba) ^ data_i[51];
data_o[52] = (syndrome_o == 8'hbb) ^ data_i[52];
data_o[53] = (syndrome_o == 8'hbc) ^ data_i[53];
data_o[54] = (syndrome_o == 8'hbd) ^ data_i[54];
data_o[55] = (syndrome_o == 8'hbe) ^ data_i[55];
data_o[56] = (syndrome_o == 8'hbf) ^ data_i[56];
data_o[57] = (syndrome_o == 8'hc1) ^ data_i[57];
data_o[58] = (syndrome_o == 8'hc2) ^ data_i[58];
data_o[59] = (syndrome_o == 8'hc3) ^ data_i[59];
data_o[60] = (syndrome_o == 8'hc4) ^ data_i[60];
data_o[61] = (syndrome_o == 8'hc5) ^ data_i[61];
data_o[62] = (syndrome_o == 8'hc6) ^ data_i[62];
data_o[63] = (syndrome_o == 8'hc7) ^ data_i[63];
data_o[64] = (syndrome_o == 8'hc8) ^ data_i[64];
data_o[65] = (syndrome_o == 8'hc9) ^ data_i[65];
data_o[66] = (syndrome_o == 8'hca) ^ data_i[66];
data_o[67] = (syndrome_o == 8'hcb) ^ data_i[67];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = syndrome_o[7];
err_o[1] = |syndrome_o[6:0] & ~syndrome_o[7];
end
endmodule : prim_secded_hamming_76_68_dec

45
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_22_16_dec.sv vendored Normal file
View file

@ -0,0 +1,45 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED decoder generated by util/design/secded_gen.py
module prim_secded_inv_22_16_dec (
input [21:0] data_i,
output logic [15:0] data_o,
output logic [5:0] syndrome_o,
output logic [1:0] err_o
);
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^((data_i ^ 22'h3F0000) & 22'h01496E);
syndrome_o[1] = ^((data_i ^ 22'h3F0000) & 22'h02F20B);
syndrome_o[2] = ^((data_i ^ 22'h3F0000) & 22'h048ED8);
syndrome_o[3] = ^((data_i ^ 22'h3F0000) & 22'h087714);
syndrome_o[4] = ^((data_i ^ 22'h3F0000) & 22'h10ACA5);
syndrome_o[5] = ^((data_i ^ 22'h3F0000) & 22'h2011F3);
// Corrected output calculation
data_o[0] = (syndrome_o == 6'h32) ^ data_i[0];
data_o[1] = (syndrome_o == 6'h23) ^ data_i[1];
data_o[2] = (syndrome_o == 6'h19) ^ data_i[2];
data_o[3] = (syndrome_o == 6'h7) ^ data_i[3];
data_o[4] = (syndrome_o == 6'h2c) ^ data_i[4];
data_o[5] = (syndrome_o == 6'h31) ^ data_i[5];
data_o[6] = (syndrome_o == 6'h25) ^ data_i[6];
data_o[7] = (syndrome_o == 6'h34) ^ data_i[7];
data_o[8] = (syndrome_o == 6'h29) ^ data_i[8];
data_o[9] = (syndrome_o == 6'he) ^ data_i[9];
data_o[10] = (syndrome_o == 6'h1c) ^ data_i[10];
data_o[11] = (syndrome_o == 6'h15) ^ data_i[11];
data_o[12] = (syndrome_o == 6'h2a) ^ data_i[12];
data_o[13] = (syndrome_o == 6'h1a) ^ data_i[13];
data_o[14] = (syndrome_o == 6'hb) ^ data_i[14];
data_o[15] = (syndrome_o == 6'h16) ^ data_i[15];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = ^syndrome_o;
err_o[1] = ~err_o[0] & (|syndrome_o);
end
endmodule : prim_secded_inv_22_16_dec

22
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_22_16_enc.sv vendored Normal file
View file

@ -0,0 +1,22 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED encoder generated by util/design/secded_gen.py
module prim_secded_inv_22_16_enc (
input [15:0] data_i,
output logic [21:0] data_o
);
always_comb begin : p_encode
data_o = 22'(data_i);
data_o[16] = ~^(data_o & 22'h00496E);
data_o[17] = ~^(data_o & 22'h00F20B);
data_o[18] = ~^(data_o & 22'h008ED8);
data_o[19] = ~^(data_o & 22'h007714);
data_o[20] = ~^(data_o & 22'h00ACA5);
data_o[21] = ~^(data_o & 22'h0011F3);
end
endmodule : prim_secded_inv_22_16_enc

51
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_28_22_dec.sv vendored Normal file
View file

@ -0,0 +1,51 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED decoder generated by util/design/secded_gen.py
module prim_secded_inv_28_22_dec (
input [27:0] data_i,
output logic [21:0] data_o,
output logic [5:0] syndrome_o,
output logic [1:0] err_o
);
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^((data_i ^ 28'hFC00000) & 28'h07003FF);
syndrome_o[1] = ^((data_i ^ 28'hFC00000) & 28'h090FC0F);
syndrome_o[2] = ^((data_i ^ 28'hFC00000) & 28'h1271C71);
syndrome_o[3] = ^((data_i ^ 28'hFC00000) & 28'h23B6592);
syndrome_o[4] = ^((data_i ^ 28'hFC00000) & 28'h43DAAA4);
syndrome_o[5] = ^((data_i ^ 28'hFC00000) & 28'h83ED348);
// Corrected output calculation
data_o[0] = (syndrome_o == 6'h7) ^ data_i[0];
data_o[1] = (syndrome_o == 6'hb) ^ data_i[1];
data_o[2] = (syndrome_o == 6'h13) ^ data_i[2];
data_o[3] = (syndrome_o == 6'h23) ^ data_i[3];
data_o[4] = (syndrome_o == 6'hd) ^ data_i[4];
data_o[5] = (syndrome_o == 6'h15) ^ data_i[5];
data_o[6] = (syndrome_o == 6'h25) ^ data_i[6];
data_o[7] = (syndrome_o == 6'h19) ^ data_i[7];
data_o[8] = (syndrome_o == 6'h29) ^ data_i[8];
data_o[9] = (syndrome_o == 6'h31) ^ data_i[9];
data_o[10] = (syndrome_o == 6'he) ^ data_i[10];
data_o[11] = (syndrome_o == 6'h16) ^ data_i[11];
data_o[12] = (syndrome_o == 6'h26) ^ data_i[12];
data_o[13] = (syndrome_o == 6'h1a) ^ data_i[13];
data_o[14] = (syndrome_o == 6'h2a) ^ data_i[14];
data_o[15] = (syndrome_o == 6'h32) ^ data_i[15];
data_o[16] = (syndrome_o == 6'h1c) ^ data_i[16];
data_o[17] = (syndrome_o == 6'h2c) ^ data_i[17];
data_o[18] = (syndrome_o == 6'h34) ^ data_i[18];
data_o[19] = (syndrome_o == 6'h38) ^ data_i[19];
data_o[20] = (syndrome_o == 6'h3b) ^ data_i[20];
data_o[21] = (syndrome_o == 6'h3d) ^ data_i[21];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = ^syndrome_o;
err_o[1] = ~err_o[0] & (|syndrome_o);
end
endmodule : prim_secded_inv_28_22_dec

22
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_28_22_enc.sv vendored Normal file
View file

@ -0,0 +1,22 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED encoder generated by util/design/secded_gen.py
module prim_secded_inv_28_22_enc (
input [21:0] data_i,
output logic [27:0] data_o
);
always_comb begin : p_encode
data_o = 28'(data_i);
data_o[22] = ~^(data_o & 28'h03003FF);
data_o[23] = ~^(data_o & 28'h010FC0F);
data_o[24] = ~^(data_o & 28'h0271C71);
data_o[25] = ~^(data_o & 28'h03B6592);
data_o[26] = ~^(data_o & 28'h03DAAA4);
data_o[27] = ~^(data_o & 28'h03ED348);
end
endmodule : prim_secded_inv_28_22_enc

62
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_39_32_dec.sv vendored Normal file
View file

@ -0,0 +1,62 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED decoder generated by util/design/secded_gen.py
module prim_secded_inv_39_32_dec (
input [38:0] data_i,
output logic [31:0] data_o,
output logic [6:0] syndrome_o,
output logic [1:0] err_o
);
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^((data_i ^ 39'h7F00000000) & 39'h012606BD25);
syndrome_o[1] = ^((data_i ^ 39'h7F00000000) & 39'h02DEBA8050);
syndrome_o[2] = ^((data_i ^ 39'h7F00000000) & 39'h04413D89AA);
syndrome_o[3] = ^((data_i ^ 39'h7F00000000) & 39'h0831234ED1);
syndrome_o[4] = ^((data_i ^ 39'h7F00000000) & 39'h10C2C1323B);
syndrome_o[5] = ^((data_i ^ 39'h7F00000000) & 39'h202DCC624C);
syndrome_o[6] = ^((data_i ^ 39'h7F00000000) & 39'h4098505586);
// Corrected output calculation
data_o[0] = (syndrome_o == 7'h19) ^ data_i[0];
data_o[1] = (syndrome_o == 7'h54) ^ data_i[1];
data_o[2] = (syndrome_o == 7'h61) ^ data_i[2];
data_o[3] = (syndrome_o == 7'h34) ^ data_i[3];
data_o[4] = (syndrome_o == 7'h1a) ^ data_i[4];
data_o[5] = (syndrome_o == 7'h15) ^ data_i[5];
data_o[6] = (syndrome_o == 7'h2a) ^ data_i[6];
data_o[7] = (syndrome_o == 7'h4c) ^ data_i[7];
data_o[8] = (syndrome_o == 7'h45) ^ data_i[8];
data_o[9] = (syndrome_o == 7'h38) ^ data_i[9];
data_o[10] = (syndrome_o == 7'h49) ^ data_i[10];
data_o[11] = (syndrome_o == 7'hd) ^ data_i[11];
data_o[12] = (syndrome_o == 7'h51) ^ data_i[12];
data_o[13] = (syndrome_o == 7'h31) ^ data_i[13];
data_o[14] = (syndrome_o == 7'h68) ^ data_i[14];
data_o[15] = (syndrome_o == 7'h7) ^ data_i[15];
data_o[16] = (syndrome_o == 7'h1c) ^ data_i[16];
data_o[17] = (syndrome_o == 7'hb) ^ data_i[17];
data_o[18] = (syndrome_o == 7'h25) ^ data_i[18];
data_o[19] = (syndrome_o == 7'h26) ^ data_i[19];
data_o[20] = (syndrome_o == 7'h46) ^ data_i[20];
data_o[21] = (syndrome_o == 7'he) ^ data_i[21];
data_o[22] = (syndrome_o == 7'h70) ^ data_i[22];
data_o[23] = (syndrome_o == 7'h32) ^ data_i[23];
data_o[24] = (syndrome_o == 7'h2c) ^ data_i[24];
data_o[25] = (syndrome_o == 7'h13) ^ data_i[25];
data_o[26] = (syndrome_o == 7'h23) ^ data_i[26];
data_o[27] = (syndrome_o == 7'h62) ^ data_i[27];
data_o[28] = (syndrome_o == 7'h4a) ^ data_i[28];
data_o[29] = (syndrome_o == 7'h29) ^ data_i[29];
data_o[30] = (syndrome_o == 7'h16) ^ data_i[30];
data_o[31] = (syndrome_o == 7'h52) ^ data_i[31];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = ^syndrome_o;
err_o[1] = ~err_o[0] & (|syndrome_o);
end
endmodule : prim_secded_inv_39_32_dec

23
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_39_32_enc.sv vendored Normal file
View file

@ -0,0 +1,23 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED encoder generated by util/design/secded_gen.py
module prim_secded_inv_39_32_enc (
input [31:0] data_i,
output logic [38:0] data_o
);
always_comb begin : p_encode
data_o = 39'(data_i);
data_o[32] = ~^(data_o & 39'h002606BD25);
data_o[33] = ~^(data_o & 39'h00DEBA8050);
data_o[34] = ~^(data_o & 39'h00413D89AA);
data_o[35] = ~^(data_o & 39'h0031234ED1);
data_o[36] = ~^(data_o & 39'h00C2C1323B);
data_o[37] = ~^(data_o & 39'h002DCC624C);
data_o[38] = ~^(data_o & 39'h0098505586);
end
endmodule : prim_secded_inv_39_32_enc

87
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_64_57_dec.sv vendored Normal file
View file

@ -0,0 +1,87 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED decoder generated by util/design/secded_gen.py
module prim_secded_inv_64_57_dec (
input [63:0] data_i,
output logic [56:0] data_o,
output logic [6:0] syndrome_o,
output logic [1:0] err_o
);
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^((data_i ^ 64'hFE00000000000000) & 64'h0303FFF800007FFF);
syndrome_o[1] = ^((data_i ^ 64'hFE00000000000000) & 64'h057C1FF801FF801F);
syndrome_o[2] = ^((data_i ^ 64'hFE00000000000000) & 64'h09BDE1F87E0781E1);
syndrome_o[3] = ^((data_i ^ 64'hFE00000000000000) & 64'h11DEEE3B8E388E22);
syndrome_o[4] = ^((data_i ^ 64'hFE00000000000000) & 64'h21EF76CDB2C93244);
syndrome_o[5] = ^((data_i ^ 64'hFE00000000000000) & 64'h41F7BB56D5525488);
syndrome_o[6] = ^((data_i ^ 64'hFE00000000000000) & 64'h81FBDDA769A46910);
// Corrected output calculation
data_o[0] = (syndrome_o == 7'h7) ^ data_i[0];
data_o[1] = (syndrome_o == 7'hb) ^ data_i[1];
data_o[2] = (syndrome_o == 7'h13) ^ data_i[2];
data_o[3] = (syndrome_o == 7'h23) ^ data_i[3];
data_o[4] = (syndrome_o == 7'h43) ^ data_i[4];
data_o[5] = (syndrome_o == 7'hd) ^ data_i[5];
data_o[6] = (syndrome_o == 7'h15) ^ data_i[6];
data_o[7] = (syndrome_o == 7'h25) ^ data_i[7];
data_o[8] = (syndrome_o == 7'h45) ^ data_i[8];
data_o[9] = (syndrome_o == 7'h19) ^ data_i[9];
data_o[10] = (syndrome_o == 7'h29) ^ data_i[10];
data_o[11] = (syndrome_o == 7'h49) ^ data_i[11];
data_o[12] = (syndrome_o == 7'h31) ^ data_i[12];
data_o[13] = (syndrome_o == 7'h51) ^ data_i[13];
data_o[14] = (syndrome_o == 7'h61) ^ data_i[14];
data_o[15] = (syndrome_o == 7'he) ^ data_i[15];
data_o[16] = (syndrome_o == 7'h16) ^ data_i[16];
data_o[17] = (syndrome_o == 7'h26) ^ data_i[17];
data_o[18] = (syndrome_o == 7'h46) ^ data_i[18];
data_o[19] = (syndrome_o == 7'h1a) ^ data_i[19];
data_o[20] = (syndrome_o == 7'h2a) ^ data_i[20];
data_o[21] = (syndrome_o == 7'h4a) ^ data_i[21];
data_o[22] = (syndrome_o == 7'h32) ^ data_i[22];
data_o[23] = (syndrome_o == 7'h52) ^ data_i[23];
data_o[24] = (syndrome_o == 7'h62) ^ data_i[24];
data_o[25] = (syndrome_o == 7'h1c) ^ data_i[25];
data_o[26] = (syndrome_o == 7'h2c) ^ data_i[26];
data_o[27] = (syndrome_o == 7'h4c) ^ data_i[27];
data_o[28] = (syndrome_o == 7'h34) ^ data_i[28];
data_o[29] = (syndrome_o == 7'h54) ^ data_i[29];
data_o[30] = (syndrome_o == 7'h64) ^ data_i[30];
data_o[31] = (syndrome_o == 7'h38) ^ data_i[31];
data_o[32] = (syndrome_o == 7'h58) ^ data_i[32];
data_o[33] = (syndrome_o == 7'h68) ^ data_i[33];
data_o[34] = (syndrome_o == 7'h70) ^ data_i[34];
data_o[35] = (syndrome_o == 7'h1f) ^ data_i[35];
data_o[36] = (syndrome_o == 7'h2f) ^ data_i[36];
data_o[37] = (syndrome_o == 7'h4f) ^ data_i[37];
data_o[38] = (syndrome_o == 7'h37) ^ data_i[38];
data_o[39] = (syndrome_o == 7'h57) ^ data_i[39];
data_o[40] = (syndrome_o == 7'h67) ^ data_i[40];
data_o[41] = (syndrome_o == 7'h3b) ^ data_i[41];
data_o[42] = (syndrome_o == 7'h5b) ^ data_i[42];
data_o[43] = (syndrome_o == 7'h6b) ^ data_i[43];
data_o[44] = (syndrome_o == 7'h73) ^ data_i[44];
data_o[45] = (syndrome_o == 7'h3d) ^ data_i[45];
data_o[46] = (syndrome_o == 7'h5d) ^ data_i[46];
data_o[47] = (syndrome_o == 7'h6d) ^ data_i[47];
data_o[48] = (syndrome_o == 7'h75) ^ data_i[48];
data_o[49] = (syndrome_o == 7'h79) ^ data_i[49];
data_o[50] = (syndrome_o == 7'h3e) ^ data_i[50];
data_o[51] = (syndrome_o == 7'h5e) ^ data_i[51];
data_o[52] = (syndrome_o == 7'h6e) ^ data_i[52];
data_o[53] = (syndrome_o == 7'h76) ^ data_i[53];
data_o[54] = (syndrome_o == 7'h7a) ^ data_i[54];
data_o[55] = (syndrome_o == 7'h7c) ^ data_i[55];
data_o[56] = (syndrome_o == 7'h7f) ^ data_i[56];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = ^syndrome_o;
err_o[1] = ~err_o[0] & (|syndrome_o);
end
endmodule : prim_secded_inv_64_57_dec

23
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_64_57_enc.sv vendored Normal file
View file

@ -0,0 +1,23 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED encoder generated by util/design/secded_gen.py
module prim_secded_inv_64_57_enc (
input [56:0] data_i,
output logic [63:0] data_o
);
always_comb begin : p_encode
data_o = 64'(data_i);
data_o[57] = ~^(data_o & 64'h0103FFF800007FFF);
data_o[58] = ~^(data_o & 64'h017C1FF801FF801F);
data_o[59] = ~^(data_o & 64'h01BDE1F87E0781E1);
data_o[60] = ~^(data_o & 64'h01DEEE3B8E388E22);
data_o[61] = ~^(data_o & 64'h01EF76CDB2C93244);
data_o[62] = ~^(data_o & 64'h01F7BB56D5525488);
data_o[63] = ~^(data_o & 64'h01FBDDA769A46910);
end
endmodule : prim_secded_inv_64_57_enc

95
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_72_64_dec.sv vendored Normal file
View file

@ -0,0 +1,95 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED decoder generated by util/design/secded_gen.py
module prim_secded_inv_72_64_dec (
input [71:0] data_i,
output logic [63:0] data_o,
output logic [7:0] syndrome_o,
output logic [1:0] err_o
);
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^((data_i ^ 72'hFF0000000000000000) & 72'h01B9000000001FFFFF);
syndrome_o[1] = ^((data_i ^ 72'hFF0000000000000000) & 72'h025E00000FFFE0003F);
syndrome_o[2] = ^((data_i ^ 72'hFF0000000000000000) & 72'h0467003FF003E007C1);
syndrome_o[3] = ^((data_i ^ 72'hFF0000000000000000) & 72'h08CD0FC0F03C207842);
syndrome_o[4] = ^((data_i ^ 72'hFF0000000000000000) & 72'h10B671C711C4438884);
syndrome_o[5] = ^((data_i ^ 72'hFF0000000000000000) & 72'h20B5B65926488C9108);
syndrome_o[6] = ^((data_i ^ 72'hFF0000000000000000) & 72'h40CBDAAA4A91152210);
syndrome_o[7] = ^((data_i ^ 72'hFF0000000000000000) & 72'h807AED348D221A4420);
// Corrected output calculation
data_o[0] = (syndrome_o == 8'h7) ^ data_i[0];
data_o[1] = (syndrome_o == 8'hb) ^ data_i[1];
data_o[2] = (syndrome_o == 8'h13) ^ data_i[2];
data_o[3] = (syndrome_o == 8'h23) ^ data_i[3];
data_o[4] = (syndrome_o == 8'h43) ^ data_i[4];
data_o[5] = (syndrome_o == 8'h83) ^ data_i[5];
data_o[6] = (syndrome_o == 8'hd) ^ data_i[6];
data_o[7] = (syndrome_o == 8'h15) ^ data_i[7];
data_o[8] = (syndrome_o == 8'h25) ^ data_i[8];
data_o[9] = (syndrome_o == 8'h45) ^ data_i[9];
data_o[10] = (syndrome_o == 8'h85) ^ data_i[10];
data_o[11] = (syndrome_o == 8'h19) ^ data_i[11];
data_o[12] = (syndrome_o == 8'h29) ^ data_i[12];
data_o[13] = (syndrome_o == 8'h49) ^ data_i[13];
data_o[14] = (syndrome_o == 8'h89) ^ data_i[14];
data_o[15] = (syndrome_o == 8'h31) ^ data_i[15];
data_o[16] = (syndrome_o == 8'h51) ^ data_i[16];
data_o[17] = (syndrome_o == 8'h91) ^ data_i[17];
data_o[18] = (syndrome_o == 8'h61) ^ data_i[18];
data_o[19] = (syndrome_o == 8'ha1) ^ data_i[19];
data_o[20] = (syndrome_o == 8'hc1) ^ data_i[20];
data_o[21] = (syndrome_o == 8'he) ^ data_i[21];
data_o[22] = (syndrome_o == 8'h16) ^ data_i[22];
data_o[23] = (syndrome_o == 8'h26) ^ data_i[23];
data_o[24] = (syndrome_o == 8'h46) ^ data_i[24];
data_o[25] = (syndrome_o == 8'h86) ^ data_i[25];
data_o[26] = (syndrome_o == 8'h1a) ^ data_i[26];
data_o[27] = (syndrome_o == 8'h2a) ^ data_i[27];
data_o[28] = (syndrome_o == 8'h4a) ^ data_i[28];
data_o[29] = (syndrome_o == 8'h8a) ^ data_i[29];
data_o[30] = (syndrome_o == 8'h32) ^ data_i[30];
data_o[31] = (syndrome_o == 8'h52) ^ data_i[31];
data_o[32] = (syndrome_o == 8'h92) ^ data_i[32];
data_o[33] = (syndrome_o == 8'h62) ^ data_i[33];
data_o[34] = (syndrome_o == 8'ha2) ^ data_i[34];
data_o[35] = (syndrome_o == 8'hc2) ^ data_i[35];
data_o[36] = (syndrome_o == 8'h1c) ^ data_i[36];
data_o[37] = (syndrome_o == 8'h2c) ^ data_i[37];
data_o[38] = (syndrome_o == 8'h4c) ^ data_i[38];
data_o[39] = (syndrome_o == 8'h8c) ^ data_i[39];
data_o[40] = (syndrome_o == 8'h34) ^ data_i[40];
data_o[41] = (syndrome_o == 8'h54) ^ data_i[41];
data_o[42] = (syndrome_o == 8'h94) ^ data_i[42];
data_o[43] = (syndrome_o == 8'h64) ^ data_i[43];
data_o[44] = (syndrome_o == 8'ha4) ^ data_i[44];
data_o[45] = (syndrome_o == 8'hc4) ^ data_i[45];
data_o[46] = (syndrome_o == 8'h38) ^ data_i[46];
data_o[47] = (syndrome_o == 8'h58) ^ data_i[47];
data_o[48] = (syndrome_o == 8'h98) ^ data_i[48];
data_o[49] = (syndrome_o == 8'h68) ^ data_i[49];
data_o[50] = (syndrome_o == 8'ha8) ^ data_i[50];
data_o[51] = (syndrome_o == 8'hc8) ^ data_i[51];
data_o[52] = (syndrome_o == 8'h70) ^ data_i[52];
data_o[53] = (syndrome_o == 8'hb0) ^ data_i[53];
data_o[54] = (syndrome_o == 8'hd0) ^ data_i[54];
data_o[55] = (syndrome_o == 8'he0) ^ data_i[55];
data_o[56] = (syndrome_o == 8'h6d) ^ data_i[56];
data_o[57] = (syndrome_o == 8'hd6) ^ data_i[57];
data_o[58] = (syndrome_o == 8'h3e) ^ data_i[58];
data_o[59] = (syndrome_o == 8'hcb) ^ data_i[59];
data_o[60] = (syndrome_o == 8'hb3) ^ data_i[60];
data_o[61] = (syndrome_o == 8'hb5) ^ data_i[61];
data_o[62] = (syndrome_o == 8'hce) ^ data_i[62];
data_o[63] = (syndrome_o == 8'h79) ^ data_i[63];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = ^syndrome_o;
err_o[1] = ~err_o[0] & (|syndrome_o);
end
endmodule : prim_secded_inv_72_64_dec

24
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_72_64_enc.sv vendored Normal file
View file

@ -0,0 +1,24 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED encoder generated by util/design/secded_gen.py
module prim_secded_inv_72_64_enc (
input [63:0] data_i,
output logic [71:0] data_o
);
always_comb begin : p_encode
data_o = 72'(data_i);
data_o[64] = ~^(data_o & 72'h00B9000000001FFFFF);
data_o[65] = ~^(data_o & 72'h005E00000FFFE0003F);
data_o[66] = ~^(data_o & 72'h0067003FF003E007C1);
data_o[67] = ~^(data_o & 72'h00CD0FC0F03C207842);
data_o[68] = ~^(data_o & 72'h00B671C711C4438884);
data_o[69] = ~^(data_o & 72'h00B5B65926488C9108);
data_o[70] = ~^(data_o & 72'h00CBDAAA4A91152210);
data_o[71] = ~^(data_o & 72'h007AED348D221A4420);
end
endmodule : prim_secded_inv_72_64_enc

45
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_hamming_22_16_dec.sv vendored Normal file
View file

@ -0,0 +1,45 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED decoder generated by util/design/secded_gen.py
module prim_secded_inv_hamming_22_16_dec (
input [21:0] data_i,
output logic [15:0] data_o,
output logic [5:0] syndrome_o,
output logic [1:0] err_o
);
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^((data_i ^ 22'h3F0000) & 22'h01AD5B);
syndrome_o[1] = ^((data_i ^ 22'h3F0000) & 22'h02366D);
syndrome_o[2] = ^((data_i ^ 22'h3F0000) & 22'h04C78E);
syndrome_o[3] = ^((data_i ^ 22'h3F0000) & 22'h0807F0);
syndrome_o[4] = ^((data_i ^ 22'h3F0000) & 22'h10F800);
syndrome_o[5] = ^((data_i ^ 22'h3F0000) & 22'h3FFFFF);
// Corrected output calculation
data_o[0] = (syndrome_o == 6'h23) ^ data_i[0];
data_o[1] = (syndrome_o == 6'h25) ^ data_i[1];
data_o[2] = (syndrome_o == 6'h26) ^ data_i[2];
data_o[3] = (syndrome_o == 6'h27) ^ data_i[3];
data_o[4] = (syndrome_o == 6'h29) ^ data_i[4];
data_o[5] = (syndrome_o == 6'h2a) ^ data_i[5];
data_o[6] = (syndrome_o == 6'h2b) ^ data_i[6];
data_o[7] = (syndrome_o == 6'h2c) ^ data_i[7];
data_o[8] = (syndrome_o == 6'h2d) ^ data_i[8];
data_o[9] = (syndrome_o == 6'h2e) ^ data_i[9];
data_o[10] = (syndrome_o == 6'h2f) ^ data_i[10];
data_o[11] = (syndrome_o == 6'h31) ^ data_i[11];
data_o[12] = (syndrome_o == 6'h32) ^ data_i[12];
data_o[13] = (syndrome_o == 6'h33) ^ data_i[13];
data_o[14] = (syndrome_o == 6'h34) ^ data_i[14];
data_o[15] = (syndrome_o == 6'h35) ^ data_i[15];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = syndrome_o[5];
err_o[1] = |syndrome_o[4:0] & ~syndrome_o[5];
end
endmodule : prim_secded_inv_hamming_22_16_dec

22
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_hamming_22_16_enc.sv vendored Normal file
View file

@ -0,0 +1,22 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED encoder generated by util/design/secded_gen.py
module prim_secded_inv_hamming_22_16_enc (
input [15:0] data_i,
output logic [21:0] data_o
);
always_comb begin : p_encode
data_o = 22'(data_i);
data_o[16] = ~^(data_o & 22'h00AD5B);
data_o[17] = ~^(data_o & 22'h00366D);
data_o[18] = ~^(data_o & 22'h00C78E);
data_o[19] = ~^(data_o & 22'h0007F0);
data_o[20] = ~^(data_o & 22'h00F800);
data_o[21] = ~^(data_o & 22'h1FFFFF);
end
endmodule : prim_secded_inv_hamming_22_16_enc

62
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_hamming_39_32_dec.sv vendored Normal file
View file

@ -0,0 +1,62 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED decoder generated by util/design/secded_gen.py
module prim_secded_inv_hamming_39_32_dec (
input [38:0] data_i,
output logic [31:0] data_o,
output logic [6:0] syndrome_o,
output logic [1:0] err_o
);
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^((data_i ^ 39'h7F00000000) & 39'h0156AAAD5B);
syndrome_o[1] = ^((data_i ^ 39'h7F00000000) & 39'h029B33366D);
syndrome_o[2] = ^((data_i ^ 39'h7F00000000) & 39'h04E3C3C78E);
syndrome_o[3] = ^((data_i ^ 39'h7F00000000) & 39'h0803FC07F0);
syndrome_o[4] = ^((data_i ^ 39'h7F00000000) & 39'h1003FFF800);
syndrome_o[5] = ^((data_i ^ 39'h7F00000000) & 39'h20FC000000);
syndrome_o[6] = ^((data_i ^ 39'h7F00000000) & 39'h7FFFFFFFFF);
// Corrected output calculation
data_o[0] = (syndrome_o == 7'h43) ^ data_i[0];
data_o[1] = (syndrome_o == 7'h45) ^ data_i[1];
data_o[2] = (syndrome_o == 7'h46) ^ data_i[2];
data_o[3] = (syndrome_o == 7'h47) ^ data_i[3];
data_o[4] = (syndrome_o == 7'h49) ^ data_i[4];
data_o[5] = (syndrome_o == 7'h4a) ^ data_i[5];
data_o[6] = (syndrome_o == 7'h4b) ^ data_i[6];
data_o[7] = (syndrome_o == 7'h4c) ^ data_i[7];
data_o[8] = (syndrome_o == 7'h4d) ^ data_i[8];
data_o[9] = (syndrome_o == 7'h4e) ^ data_i[9];
data_o[10] = (syndrome_o == 7'h4f) ^ data_i[10];
data_o[11] = (syndrome_o == 7'h51) ^ data_i[11];
data_o[12] = (syndrome_o == 7'h52) ^ data_i[12];
data_o[13] = (syndrome_o == 7'h53) ^ data_i[13];
data_o[14] = (syndrome_o == 7'h54) ^ data_i[14];
data_o[15] = (syndrome_o == 7'h55) ^ data_i[15];
data_o[16] = (syndrome_o == 7'h56) ^ data_i[16];
data_o[17] = (syndrome_o == 7'h57) ^ data_i[17];
data_o[18] = (syndrome_o == 7'h58) ^ data_i[18];
data_o[19] = (syndrome_o == 7'h59) ^ data_i[19];
data_o[20] = (syndrome_o == 7'h5a) ^ data_i[20];
data_o[21] = (syndrome_o == 7'h5b) ^ data_i[21];
data_o[22] = (syndrome_o == 7'h5c) ^ data_i[22];
data_o[23] = (syndrome_o == 7'h5d) ^ data_i[23];
data_o[24] = (syndrome_o == 7'h5e) ^ data_i[24];
data_o[25] = (syndrome_o == 7'h5f) ^ data_i[25];
data_o[26] = (syndrome_o == 7'h61) ^ data_i[26];
data_o[27] = (syndrome_o == 7'h62) ^ data_i[27];
data_o[28] = (syndrome_o == 7'h63) ^ data_i[28];
data_o[29] = (syndrome_o == 7'h64) ^ data_i[29];
data_o[30] = (syndrome_o == 7'h65) ^ data_i[30];
data_o[31] = (syndrome_o == 7'h66) ^ data_i[31];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = syndrome_o[6];
err_o[1] = |syndrome_o[5:0] & ~syndrome_o[6];
end
endmodule : prim_secded_inv_hamming_39_32_dec

23
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_hamming_39_32_enc.sv vendored Normal file
View file

@ -0,0 +1,23 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED encoder generated by util/design/secded_gen.py
module prim_secded_inv_hamming_39_32_enc (
input [31:0] data_i,
output logic [38:0] data_o
);
always_comb begin : p_encode
data_o = 39'(data_i);
data_o[32] = ~^(data_o & 39'h0056AAAD5B);
data_o[33] = ~^(data_o & 39'h009B33366D);
data_o[34] = ~^(data_o & 39'h00E3C3C78E);
data_o[35] = ~^(data_o & 39'h0003FC07F0);
data_o[36] = ~^(data_o & 39'h0003FFF800);
data_o[37] = ~^(data_o & 39'h00FC000000);
data_o[38] = ~^(data_o & 39'h3FFFFFFFFF);
end
endmodule : prim_secded_inv_hamming_39_32_enc

95
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_hamming_72_64_dec.sv vendored Normal file
View file

@ -0,0 +1,95 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED decoder generated by util/design/secded_gen.py
module prim_secded_inv_hamming_72_64_dec (
input [71:0] data_i,
output logic [63:0] data_o,
output logic [7:0] syndrome_o,
output logic [1:0] err_o
);
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^((data_i ^ 72'hFF0000000000000000) & 72'h01AB55555556AAAD5B);
syndrome_o[1] = ^((data_i ^ 72'hFF0000000000000000) & 72'h02CD9999999B33366D);
syndrome_o[2] = ^((data_i ^ 72'hFF0000000000000000) & 72'h04F1E1E1E1E3C3C78E);
syndrome_o[3] = ^((data_i ^ 72'hFF0000000000000000) & 72'h0801FE01FE03FC07F0);
syndrome_o[4] = ^((data_i ^ 72'hFF0000000000000000) & 72'h1001FFFE0003FFF800);
syndrome_o[5] = ^((data_i ^ 72'hFF0000000000000000) & 72'h2001FFFFFFFC000000);
syndrome_o[6] = ^((data_i ^ 72'hFF0000000000000000) & 72'h40FE00000000000000);
syndrome_o[7] = ^((data_i ^ 72'hFF0000000000000000) & 72'hFFFFFFFFFFFFFFFFFF);
// Corrected output calculation
data_o[0] = (syndrome_o == 8'h83) ^ data_i[0];
data_o[1] = (syndrome_o == 8'h85) ^ data_i[1];
data_o[2] = (syndrome_o == 8'h86) ^ data_i[2];
data_o[3] = (syndrome_o == 8'h87) ^ data_i[3];
data_o[4] = (syndrome_o == 8'h89) ^ data_i[4];
data_o[5] = (syndrome_o == 8'h8a) ^ data_i[5];
data_o[6] = (syndrome_o == 8'h8b) ^ data_i[6];
data_o[7] = (syndrome_o == 8'h8c) ^ data_i[7];
data_o[8] = (syndrome_o == 8'h8d) ^ data_i[8];
data_o[9] = (syndrome_o == 8'h8e) ^ data_i[9];
data_o[10] = (syndrome_o == 8'h8f) ^ data_i[10];
data_o[11] = (syndrome_o == 8'h91) ^ data_i[11];
data_o[12] = (syndrome_o == 8'h92) ^ data_i[12];
data_o[13] = (syndrome_o == 8'h93) ^ data_i[13];
data_o[14] = (syndrome_o == 8'h94) ^ data_i[14];
data_o[15] = (syndrome_o == 8'h95) ^ data_i[15];
data_o[16] = (syndrome_o == 8'h96) ^ data_i[16];
data_o[17] = (syndrome_o == 8'h97) ^ data_i[17];
data_o[18] = (syndrome_o == 8'h98) ^ data_i[18];
data_o[19] = (syndrome_o == 8'h99) ^ data_i[19];
data_o[20] = (syndrome_o == 8'h9a) ^ data_i[20];
data_o[21] = (syndrome_o == 8'h9b) ^ data_i[21];
data_o[22] = (syndrome_o == 8'h9c) ^ data_i[22];
data_o[23] = (syndrome_o == 8'h9d) ^ data_i[23];
data_o[24] = (syndrome_o == 8'h9e) ^ data_i[24];
data_o[25] = (syndrome_o == 8'h9f) ^ data_i[25];
data_o[26] = (syndrome_o == 8'ha1) ^ data_i[26];
data_o[27] = (syndrome_o == 8'ha2) ^ data_i[27];
data_o[28] = (syndrome_o == 8'ha3) ^ data_i[28];
data_o[29] = (syndrome_o == 8'ha4) ^ data_i[29];
data_o[30] = (syndrome_o == 8'ha5) ^ data_i[30];
data_o[31] = (syndrome_o == 8'ha6) ^ data_i[31];
data_o[32] = (syndrome_o == 8'ha7) ^ data_i[32];
data_o[33] = (syndrome_o == 8'ha8) ^ data_i[33];
data_o[34] = (syndrome_o == 8'ha9) ^ data_i[34];
data_o[35] = (syndrome_o == 8'haa) ^ data_i[35];
data_o[36] = (syndrome_o == 8'hab) ^ data_i[36];
data_o[37] = (syndrome_o == 8'hac) ^ data_i[37];
data_o[38] = (syndrome_o == 8'had) ^ data_i[38];
data_o[39] = (syndrome_o == 8'hae) ^ data_i[39];
data_o[40] = (syndrome_o == 8'haf) ^ data_i[40];
data_o[41] = (syndrome_o == 8'hb0) ^ data_i[41];
data_o[42] = (syndrome_o == 8'hb1) ^ data_i[42];
data_o[43] = (syndrome_o == 8'hb2) ^ data_i[43];
data_o[44] = (syndrome_o == 8'hb3) ^ data_i[44];
data_o[45] = (syndrome_o == 8'hb4) ^ data_i[45];
data_o[46] = (syndrome_o == 8'hb5) ^ data_i[46];
data_o[47] = (syndrome_o == 8'hb6) ^ data_i[47];
data_o[48] = (syndrome_o == 8'hb7) ^ data_i[48];
data_o[49] = (syndrome_o == 8'hb8) ^ data_i[49];
data_o[50] = (syndrome_o == 8'hb9) ^ data_i[50];
data_o[51] = (syndrome_o == 8'hba) ^ data_i[51];
data_o[52] = (syndrome_o == 8'hbb) ^ data_i[52];
data_o[53] = (syndrome_o == 8'hbc) ^ data_i[53];
data_o[54] = (syndrome_o == 8'hbd) ^ data_i[54];
data_o[55] = (syndrome_o == 8'hbe) ^ data_i[55];
data_o[56] = (syndrome_o == 8'hbf) ^ data_i[56];
data_o[57] = (syndrome_o == 8'hc1) ^ data_i[57];
data_o[58] = (syndrome_o == 8'hc2) ^ data_i[58];
data_o[59] = (syndrome_o == 8'hc3) ^ data_i[59];
data_o[60] = (syndrome_o == 8'hc4) ^ data_i[60];
data_o[61] = (syndrome_o == 8'hc5) ^ data_i[61];
data_o[62] = (syndrome_o == 8'hc6) ^ data_i[62];
data_o[63] = (syndrome_o == 8'hc7) ^ data_i[63];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = syndrome_o[7];
err_o[1] = |syndrome_o[6:0] & ~syndrome_o[7];
end
endmodule : prim_secded_inv_hamming_72_64_dec

24
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_hamming_72_64_enc.sv vendored Normal file
View file

@ -0,0 +1,24 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED encoder generated by util/design/secded_gen.py
module prim_secded_inv_hamming_72_64_enc (
input [63:0] data_i,
output logic [71:0] data_o
);
always_comb begin : p_encode
data_o = 72'(data_i);
data_o[64] = ~^(data_o & 72'h00AB55555556AAAD5B);
data_o[65] = ~^(data_o & 72'h00CD9999999B33366D);
data_o[66] = ~^(data_o & 72'h00F1E1E1E1E3C3C78E);
data_o[67] = ~^(data_o & 72'h0001FE01FE03FC07F0);
data_o[68] = ~^(data_o & 72'h0001FFFE0003FFF800);
data_o[69] = ~^(data_o & 72'h0001FFFFFFFC000000);
data_o[70] = ~^(data_o & 72'h00FE00000000000000);
data_o[71] = ~^(data_o & 72'h7FFFFFFFFFFFFFFFFF);
end
endmodule : prim_secded_inv_hamming_72_64_enc

99
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_hamming_76_68_dec.sv vendored Normal file
View file

@ -0,0 +1,99 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED decoder generated by util/design/secded_gen.py
module prim_secded_inv_hamming_76_68_dec (
input [75:0] data_i,
output logic [67:0] data_o,
output logic [7:0] syndrome_o,
output logic [1:0] err_o
);
always_comb begin : p_encode
// Syndrome calculation
syndrome_o[0] = ^((data_i ^ 76'hFF00000000000000000) & 76'h01AAB55555556AAAD5B);
syndrome_o[1] = ^((data_i ^ 76'hFF00000000000000000) & 76'h02CCD9999999B33366D);
syndrome_o[2] = ^((data_i ^ 76'hFF00000000000000000) & 76'h040F1E1E1E1E3C3C78E);
syndrome_o[3] = ^((data_i ^ 76'hFF00000000000000000) & 76'h08F01FE01FE03FC07F0);
syndrome_o[4] = ^((data_i ^ 76'hFF00000000000000000) & 76'h10001FFFE0003FFF800);
syndrome_o[5] = ^((data_i ^ 76'hFF00000000000000000) & 76'h20001FFFFFFFC000000);
syndrome_o[6] = ^((data_i ^ 76'hFF00000000000000000) & 76'h40FFE00000000000000);
syndrome_o[7] = ^((data_i ^ 76'hFF00000000000000000) & 76'hFFFFFFFFFFFFFFFFFFF);
// Corrected output calculation
data_o[0] = (syndrome_o == 8'h83) ^ data_i[0];
data_o[1] = (syndrome_o == 8'h85) ^ data_i[1];
data_o[2] = (syndrome_o == 8'h86) ^ data_i[2];
data_o[3] = (syndrome_o == 8'h87) ^ data_i[3];
data_o[4] = (syndrome_o == 8'h89) ^ data_i[4];
data_o[5] = (syndrome_o == 8'h8a) ^ data_i[5];
data_o[6] = (syndrome_o == 8'h8b) ^ data_i[6];
data_o[7] = (syndrome_o == 8'h8c) ^ data_i[7];
data_o[8] = (syndrome_o == 8'h8d) ^ data_i[8];
data_o[9] = (syndrome_o == 8'h8e) ^ data_i[9];
data_o[10] = (syndrome_o == 8'h8f) ^ data_i[10];
data_o[11] = (syndrome_o == 8'h91) ^ data_i[11];
data_o[12] = (syndrome_o == 8'h92) ^ data_i[12];
data_o[13] = (syndrome_o == 8'h93) ^ data_i[13];
data_o[14] = (syndrome_o == 8'h94) ^ data_i[14];
data_o[15] = (syndrome_o == 8'h95) ^ data_i[15];
data_o[16] = (syndrome_o == 8'h96) ^ data_i[16];
data_o[17] = (syndrome_o == 8'h97) ^ data_i[17];
data_o[18] = (syndrome_o == 8'h98) ^ data_i[18];
data_o[19] = (syndrome_o == 8'h99) ^ data_i[19];
data_o[20] = (syndrome_o == 8'h9a) ^ data_i[20];
data_o[21] = (syndrome_o == 8'h9b) ^ data_i[21];
data_o[22] = (syndrome_o == 8'h9c) ^ data_i[22];
data_o[23] = (syndrome_o == 8'h9d) ^ data_i[23];
data_o[24] = (syndrome_o == 8'h9e) ^ data_i[24];
data_o[25] = (syndrome_o == 8'h9f) ^ data_i[25];
data_o[26] = (syndrome_o == 8'ha1) ^ data_i[26];
data_o[27] = (syndrome_o == 8'ha2) ^ data_i[27];
data_o[28] = (syndrome_o == 8'ha3) ^ data_i[28];
data_o[29] = (syndrome_o == 8'ha4) ^ data_i[29];
data_o[30] = (syndrome_o == 8'ha5) ^ data_i[30];
data_o[31] = (syndrome_o == 8'ha6) ^ data_i[31];
data_o[32] = (syndrome_o == 8'ha7) ^ data_i[32];
data_o[33] = (syndrome_o == 8'ha8) ^ data_i[33];
data_o[34] = (syndrome_o == 8'ha9) ^ data_i[34];
data_o[35] = (syndrome_o == 8'haa) ^ data_i[35];
data_o[36] = (syndrome_o == 8'hab) ^ data_i[36];
data_o[37] = (syndrome_o == 8'hac) ^ data_i[37];
data_o[38] = (syndrome_o == 8'had) ^ data_i[38];
data_o[39] = (syndrome_o == 8'hae) ^ data_i[39];
data_o[40] = (syndrome_o == 8'haf) ^ data_i[40];
data_o[41] = (syndrome_o == 8'hb0) ^ data_i[41];
data_o[42] = (syndrome_o == 8'hb1) ^ data_i[42];
data_o[43] = (syndrome_o == 8'hb2) ^ data_i[43];
data_o[44] = (syndrome_o == 8'hb3) ^ data_i[44];
data_o[45] = (syndrome_o == 8'hb4) ^ data_i[45];
data_o[46] = (syndrome_o == 8'hb5) ^ data_i[46];
data_o[47] = (syndrome_o == 8'hb6) ^ data_i[47];
data_o[48] = (syndrome_o == 8'hb7) ^ data_i[48];
data_o[49] = (syndrome_o == 8'hb8) ^ data_i[49];
data_o[50] = (syndrome_o == 8'hb9) ^ data_i[50];
data_o[51] = (syndrome_o == 8'hba) ^ data_i[51];
data_o[52] = (syndrome_o == 8'hbb) ^ data_i[52];
data_o[53] = (syndrome_o == 8'hbc) ^ data_i[53];
data_o[54] = (syndrome_o == 8'hbd) ^ data_i[54];
data_o[55] = (syndrome_o == 8'hbe) ^ data_i[55];
data_o[56] = (syndrome_o == 8'hbf) ^ data_i[56];
data_o[57] = (syndrome_o == 8'hc1) ^ data_i[57];
data_o[58] = (syndrome_o == 8'hc2) ^ data_i[58];
data_o[59] = (syndrome_o == 8'hc3) ^ data_i[59];
data_o[60] = (syndrome_o == 8'hc4) ^ data_i[60];
data_o[61] = (syndrome_o == 8'hc5) ^ data_i[61];
data_o[62] = (syndrome_o == 8'hc6) ^ data_i[62];
data_o[63] = (syndrome_o == 8'hc7) ^ data_i[63];
data_o[64] = (syndrome_o == 8'hc8) ^ data_i[64];
data_o[65] = (syndrome_o == 8'hc9) ^ data_i[65];
data_o[66] = (syndrome_o == 8'hca) ^ data_i[66];
data_o[67] = (syndrome_o == 8'hcb) ^ data_i[67];
// err_o calc. bit0: single error, bit1: double error
err_o[0] = syndrome_o[7];
err_o[1] = |syndrome_o[6:0] & ~syndrome_o[7];
end
endmodule : prim_secded_inv_hamming_76_68_dec

24
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_inv_hamming_76_68_enc.sv vendored Normal file
View file

@ -0,0 +1,24 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
//
// SECDED encoder generated by util/design/secded_gen.py
module prim_secded_inv_hamming_76_68_enc (
input [67:0] data_i,
output logic [75:0] data_o
);
always_comb begin : p_encode
data_o = 76'(data_i);
data_o[68] = ~^(data_o & 76'h00AAB55555556AAAD5B);
data_o[69] = ~^(data_o & 76'h00CCD9999999B33366D);
data_o[70] = ~^(data_o & 76'h000F1E1E1E1E3C3C78E);
data_o[71] = ~^(data_o & 76'h00F01FE01FE03FC07F0);
data_o[72] = ~^(data_o & 76'h00001FFFE0003FFF800);
data_o[73] = ~^(data_o & 76'h00001FFFFFFFC000000);
data_o[74] = ~^(data_o & 76'h00FFE00000000000000);
data_o[75] = ~^(data_o & 76'h7FFFFFFFFFFFFFFFFFF);
end
endmodule : prim_secded_inv_hamming_76_68_enc

943
vendor/lowrisc_ip/ip/prim/rtl/prim_secded_pkg.sv vendored
View file

File diff suppressed because it is too large Load diff

55
vendor/lowrisc_ip/ip/prim/rtl/prim_sparse_fsm_flop.sv vendored Normal file
View file

@ -0,0 +1,55 @@
// Copyright lowRISC contributors.
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
`include "prim_assert.sv"
module prim_sparse_fsm_flop #(
parameter type StateEnumT = logic,
parameter int Width = 1,
parameter logic [Width-1:0] ResetValue = 0
) (
input clk_i,
input rst_ni,
input [Width-1:0] state_i,
output logic [Width-1:0] state_o
);
logic unused_valid_st;
prim_flop #(
.Width(Width),
.ResetValue(ResetValue)
) u_state_flop (
.clk_i,
.rst_ni,
.d_i(state_i),
.q_o(state_o)
);
`ifdef INC_ASSERT
StateEnumT tmp;
assign unused_valid_st = $cast(tmp, state_o);
`else
assign unused_valid_st = 1'b1;
`endif
// If ASSERT_PRIM_FSM_ERROR_TRIGGER_ALERT is declared, the unused_assert_connected signal will
// be set to 1 and the below check will pass.
// If the assertion is not declared however, the statement below will fail.
`ifdef INC_ASSERT
logic unused_assert_connected;
// ASSERT_INIT can only be used for paramters/constants in FPV.
`ifdef SIMULATION
`ASSERT_INIT(AssertConnected_A, unused_assert_connected === 1'b1)
`endif
`endif
endmodule
`define ASSERT_PRIM_FSM_ERROR_TRIGGER_ALERT(NAME_, PRIM_HIER_, ALERT_, MAX_CYCLES_ = 5) \
`ASSERT(NAME_, $fell(PRIM_HIER_.unused_valid_st) |-> ##[1:MAX_CYCLES_] $rose(ALERT_.alert_p)) \
`ifdef INC_ASSERT \
assign PRIM_HIER_.unused_assert_connected = 1'b1; \
`endif

62
vendor/lowrisc_ip/ip/prim_generic/rtl/prim_generic_flash_bank.sv vendored
View file

@ -364,16 +364,8 @@ module prim_generic_flash_bank #(
end // always_comb
//localparam int MemWidth = DataWidth - MetaDataWidth;
localparam int MemWidth = DataWidth - MetaDataWidth + 4;
localparam int EccWidth = MetaDataWidth - 4;
logic [DataWidth-1:0] rd_data_main, rd_data_info;
logic [MemWidth-1:0] rd_nom_data_main;
logic [EccWidth-1:0] rd_meta_data_main;
logic [InfoTypes-1:0][MemWidth-1:0] rd_nom_data_info;
logic [InfoTypes-1:0][EccWidth-1:0] rd_meta_data_info;
logic [InfoTypes-1:0][DataWidth-1:0] rd_nom_data_info;
// data memory is requested whenver it's a transaction targetted at the data partition
// OR if it's a bank erase
@ -383,32 +375,17 @@ module prim_generic_flash_bank #(
mem_bk_erase);
prim_ram_1p #(
.Width(MemWidth),
.Width(DataWidth),
.Depth(WordsPerBank),
.DataBitsPerMask(MemWidth)
.DataBitsPerMask(DataWidth)
) u_mem (
.clk_i,
.req_i (data_mem_req),
.write_i (mem_wr),
.addr_i (mem_addr),
.wdata_i (mem_wdata[MemWidth-1:0]),
.wmask_i ({MemWidth{1'b1}}),
.rdata_o (rd_nom_data_main),
.cfg_i ('0)
);
prim_ram_1p #(
.Width(EccWidth),
.Depth(WordsPerBank),
.DataBitsPerMask(EccWidth)
) u_mem_meta (
.clk_i,
.req_i (data_mem_req),
.write_i (mem_wr),
.addr_i (mem_addr),
.wdata_i (mem_wdata[MemWidth +: EccWidth]),
.wmask_i ({EccWidth{1'b1}}),
.rdata_o (rd_meta_data_main),
.wdata_i (mem_wdata),
.wmask_i ({DataWidth{1'b1}}),
.rdata_o (rd_data_main),
.cfg_i ('0)
);
@ -422,39 +399,22 @@ module prim_generic_flash_bank #(
((mem_info_sel == info_type) | mem_bk_erase);
prim_ram_1p #(
.Width(MemWidth),
.Width(DataWidth),
.Depth(WordsPerInfoBank),
.DataBitsPerMask(MemWidth)
.DataBitsPerMask(DataWidth)
) u_info_mem (
.clk_i,
.req_i (info_mem_req),
.write_i (mem_wr),
.addr_i (mem_addr[0 +: InfoAddrW]),
.wdata_i (mem_wdata[MemWidth-1:0]),
.wmask_i ({MemWidth{1'b1}}),
.wdata_i (mem_wdata),
.wmask_i ({DataWidth{1'b1}}),
.rdata_o (rd_nom_data_info[info_type]),
.cfg_i ('0)
);
prim_ram_1p #(
.Width(EccWidth),
.Depth(WordsPerInfoBank),
.DataBitsPerMask(EccWidth)
) u_info_mem_meta (
.clk_i,
.req_i (info_mem_req),
.write_i (mem_wr),
.addr_i (mem_addr[0 +: InfoAddrW]),
.wdata_i (mem_wdata[MemWidth +: EccWidth]),
.wmask_i ({EccWidth{1'b1}}),
.rdata_o (rd_meta_data_info[info_type]),
.cfg_i ('0)
);
end
assign rd_data_main = {rd_meta_data_main, rd_nom_data_main};
assign rd_data_info = {rd_meta_data_info[info_sel_q], rd_nom_data_info[info_sel_q]};
assign rd_data_info = rd_nom_data_info[info_sel_q];
assign rd_data_d = rd_part_q == flash_ctrl_pkg::FlashPartData ? rd_data_main : rd_data_info;
flash_ctrl_pkg::flash_prog_e unused_prog_type;

164
vendor/lowrisc_ip/lint/tools/ascentlint/parse-lint-report.py vendored
View file

@ -1,164 +0,0 @@
#!/usr/bin/env python3
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
r"""Parses lint report and dump filtered messages in hjson format.
"""
import argparse
import logging as log
import re
import sys
from pathlib import Path
import hjson
def extract_messages(full_file, patterns, results):
"""
This extracts messages from the sting buffer full_file.
The argument patterns needs to be a list of tuples with
(<error_severity>, <pattern_to_match_for>).
"""
for severity, pattern in patterns:
results[severity] += re.findall(pattern, full_file, flags=re.MULTILINE)
return results
def get_results(resdir):
"""
Parse report and corresponding logfiles and extract error, warning
and info messages for each IP present in the result folder
"""
results = {
"tool": "ascentlint",
"fusesoc-error": [],
"errors": [],
"warnings": [],
"lint_errors": [],
"lint_warnings": [],
"lint_infos": []
}
log_files = [
'ascentlint.log', 'lint-ascentlint/ascentlint.log',
'lint-ascentlint/ascentlint.rpt'
]
log_file_contents = []
# Open all log files
for name in log_files:
try:
with Path(resdir).joinpath(name).open() as f:
log_file_contents.append(f.read())
except IOError as err:
results["errors"] += ["IOError: %s" % err]
# Define warning/error patterns for each logfile
err_warn_patterns = []
# Patterns for lint.log
err_warn_patterns.append([
# If lint warnings have been found, the lint tool will exit
# with a nonzero status code and fusesoc will always spit out
# an error like
#
# ERROR: Failed to build ip:core:name:0.1 : 'make' exited with an error code
#
# If we found any other warnings or errors, there's no point in
# listing this too. BUT we want to make sure we *do* see this
# error if there are no other errors or warnings, since that
# shows something has come unstuck. (Probably the lint tool
# spat out a warning that we don't understand)
("fusesoc-error",
r"^ERROR: Failed to build .* : 'make' exited with an error code")
])
# Patterns for ascentlint.log
err_warn_patterns.append([
("errors", r"^FlexNet Licensing error.*"),
("errors", r"^Error: .*"),
("errors", r"^ERROR.*"),
("errors", r"^ ERR .*"),
("warnings", r"^Warning: .*"),
# TODO: struct assignment labels within concatenation
# not supported. check with newer ascentlint version.
("warnings", r"^ (?!WARN \[#39024\])WARN .*")
])
# Patterns for ascentlint.rpt
err_warn_patterns.append([("lint_errors", r"^E .*"),
("lint_warnings", r"^W .*"),
("lint_infos", r"^I .*")])
# Go parse the logs
for patterns, logs in zip(err_warn_patterns, log_file_contents):
extract_messages(logs, patterns, results)
# If there are no errors or warnings, add the "fusesoc-error" field to
# "errors" (which will be reported as tooling errors). Remove the
# "fusesoc-error" field either way.
if not (results['errors'] or results['warnings']):
results['errors'] = results['fusesoc-error']
del results['fusesoc-error']
return results
def main():
parser = argparse.ArgumentParser(
description="""This script parses AscentLint log and report files from
a lint run, filters the messages and creates an aggregated result
.hjson file with the following fields:
{"tool": "ascentlint",
"errors" : [],
"warnings" : [],
"lint_errors" : [],
"lint_warnings" : [],
"lint_infos" : []}
The fields 'errors' and 'warnings' contain file IO messages or
messages output by the tool itself, whereas the fields prefixed with
'lint_' contain lint-related messages.
The script returns nonzero status if any warnings or errors are present.
""")
parser.add_argument('--repdir',
type=str,
default="./",
help="""The script searches the 'ascentlint.log' and
'ascentlint.rpt' files in this directory.
Defaults to './'""")
parser.add_argument('--outdir',
type=str,
default="./",
help="""Output directory for the 'results.hjson' file.
Defaults to './'""")
args = parser.parse_args()
results = get_results(args.repdir)
with Path(args.outdir).joinpath("results.hjson").open("w") as results_file:
hjson.dump(results,
results_file,
ensure_ascii=False,
for_json=True,
use_decimal=True)
# return nonzero status if any warnings or errors are present
# lint infos do not count as failures
n_errors = len(results["errors"]) + len(results["lint_errors"])
n_warnings = len(results["warnings"]) + len(results["lint_warnings"])
if n_errors > 0 or n_warnings > 0:
log.info("Found %d lint errors and %d lint warnings", n_errors,
n_warnings)
sys.exit(1)
log.info("Lint logfile parsed succesfully")
sys.exit(0)
if __name__ == "__main__":
main()

7
vendor/lowrisc_ip/lint/tools/dvsim/ascentlint.hjson vendored
View file

@ -5,7 +5,10 @@
tool: "ascentlint"
// Ascentlint-specific results parsing script that is called after running lint
report_cmd: "{lint_root}/tools/{tool}/parse-lint-report.py "
report_cmd: "{proj_root}/util/dvsim/{tool}-report-parser.py "
report_opts: ["--repdir={build_dir}",
"--outdir={build_dir}"]
"--outfile={build_dir}/results.hjson"]
// This customizes the report format
is_style_lint: False
}

30
vendor/lowrisc_ip/lint/tools/dvsim/common_lint_cfg.hjson vendored
View file

@ -6,19 +6,19 @@
lint_root: "{proj_root}/hw/lint"
flow_makefile: "{lint_root}/tools/dvsim/lint.mk"
import_cfgs: [// common server configuration for results upload
import_cfgs: [// Common server configuration for results upload
"{proj_root}/hw/data/common_project_cfg.hjson"
// tool-specific configuration
// Tool-specific configuration
"{lint_root}/tools/dvsim/{tool}.hjson"]
// Name of the DUT / top-level to be run through lint
// Name of the DUT / top-level to be run through lint.
dut: "{name}"
// Default directory structure for the output
// Default directory structure for the output.
build_dir: "{scratch_path}/{build_mode}"
build_log: "{build_dir}/{tool}.log"
// We rely on fusesoc to run lint for us
// We rely on fusesoc to run lint for us.
build_cmd: "{job_prefix} fusesoc"
build_opts: ["--cores-root {proj_root}",
"run",
@ -28,11 +28,23 @@
"--build-root={build_dir}",
"{fusesoc_core}"]
// Common fail patterns.
build_fail_patterns: [// FuseSoC build error
"^ERROR:.*$"]
// Determines which message severities to print into report summaries.
report_severities: ["warning", "error"]
// Determines which message severities lead to a pass/fail.
fail_severities: ["warning", "error"]
// Define message bucket categories and severities.
message_buckets: [
{category: "flow", severity: "warning", label: ""},
{category: "flow", severity: "error", label: ""},
{category: "lint", severity: "info", label: ""},
{category: "lint", severity: "warning", label: ""},
{category: "lint", severity: "error", label: ""}
]
// these are not needed currently, but have to be defined
// TODO(#9079): Need to align with new parser mechanism.
build_fail_patterns: []
// These are not needed currently.
sv_flist_gen_cmd: ""
sv_flist_gen_opts: []
sv_flist_gen_dir: ""

8
vendor/lowrisc_ip/lint/tools/dvsim/veriblelint.hjson vendored
View file

@ -6,10 +6,10 @@
// TODO(#1342): switch over to native structured tool output, once supported by Verible
// Verible lint-specific results parsing script that is called after running lint
report_cmd: "{lint_root}/tools/{tool}/parse-lint-report.py "
report_opts: ["--repdir={build_dir}",
"--outdir={build_dir}"]
report_cmd: "{proj_root}/util/dvsim/{tool}-report-parser.py "
report_opts: ["--repfile={build_log}",
"--outfile={build_dir}/results.hjson"]
// This customizes the report format for style lint
// This customizes the report format
is_style_lint: True
}

9
vendor/lowrisc_ip/lint/tools/dvsim/verilator.hjson vendored
View file

@ -5,7 +5,10 @@
tool: "verilator"
// Verilator lint-specific results parsing script that is called after running lint
report_cmd: "{lint_root}/tools/{tool}/parse-lint-report.py "
report_opts: ["--logpath={build_log}",
"--reppath={build_dir}/results.hjson"]
report_cmd: "{proj_root}/util/dvsim/{tool}-report-parser.py "
report_opts: ["--repfile={build_log}",
"--outfile={build_dir}/results.hjson"]
// This customizes the report format
is_style_lint: False
}

146
vendor/lowrisc_ip/lint/tools/veriblelint/parse-lint-report.py vendored
View file

@ -1,146 +0,0 @@
#!/usr/bin/env python3
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
r"""Parses lint report and dump filtered messages in hjson format.
"""
import argparse
import logging as log
import re
import sys
from pathlib import Path
import hjson
def extract_messages(full_file, patterns, results):
"""
This extracts messages from the sting buffer full_file.
The argument patterns needs to be a list of tuples with
(<error_severity>, <pattern_to_match_for>).
"""
for severity, pattern in patterns:
results[severity] += re.findall(pattern, full_file, flags=re.MULTILINE)
return results
def get_results(resdir):
"""
Parse report and corresponding logfiles and extract error, warning
and info messages for each IP present in the result folder
"""
results = {
"tool": "veriblelint",
"fusesoc-error": [],
"errors": [],
"warnings": [],
"lint_errors": [],
"lint_warnings": [],
"lint_infos": []
}
try:
# check the report file for lint INFO, WARNING and ERRORs
with Path(resdir).joinpath('veriblelint.log').open() as f:
full_file = f.read()
except IOError as err:
results["errors"] += ["IOError: %s" % err]
err_warn_patterns = [
# If lint warnings have been found, the lint tool will exit
# with a nonzero status code and fusesoc will always spit out
# an error like
#
# ERROR: Failed to run ip:core:name:0.1 : Lint failed
#
# If we found any other warnings or errors, there's no point in
# listing this too. BUT we want to make sure we *do* see this
# error if there are no other errors or warnings, since that
# shows something has come unstuck. (Probably the lint tool
# spat out a warning that we don't understand)
("fusesoc-error", r"^ERROR: Failed to run .*: Lint failed.*"),
("errors", r"^(?!ERROR: Failed to run .* Lint failed)ERROR: .*"),
("errors", r"^.*Error: .*"),
("errors", r"^E .*"),
("errors", r"^F .*"),
("errors", r".*: syntax error, rejected.*"),
# TODO(https://github.com/olofk/edalize/issues/90):
# this is a workaround until we actually have native Edalize
# support for JasperGold and "formal" targets
("warnings",
r"^(?!WARNING: Unknown item formal in section Target)WARNING: .*"),
("warnings", r"^.*Warning: .* "),
("warnings", r"^W .*"),
("lint_warnings", r"^.*\[Style:.*")
]
extract_messages(full_file, err_warn_patterns, results)
# If there are no errors or warnings, add the "fusesoc-error" field to
# "errors" (which will be reported as tooling errors). Remove the
# "fusesoc-error" field either way.
if not (results['errors'] or results['warnings']):
results['errors'] = results['fusesoc-error']
del results['fusesoc-error']
return results
def main():
parser = argparse.ArgumentParser(
description="""This script parses verible lint log files from
a lint run, filters the messages and creates an aggregated result
.hjson file with the following fields:
{"tool": "veriblelint",
"errors" : [],
"warnings" : [],
"lint_errors" : [],
"lint_warnings" : [],
"lint_infos" : []}
The fields 'errors' and 'warnings' contain file IO messages or
messages output by the tool itself, whereas the fields prefixed with
'lint_' contain lint-related messages.
The script returns nonzero status if any warnings or errors are present.
""")
parser.add_argument('--repdir',
type=str,
default="./",
help="""The script searches the 'lint.log'
files in this directory.
Defaults to './'""")
parser.add_argument('--outdir',
type=str,
default="./",
help="""
Output directory for the 'results.hjson' file.
Defaults to '%(default)s'""")
args = parser.parse_args()
results = get_results(args.repdir)
with Path(args.outdir).joinpath("results.hjson").open("w") as results_file:
hjson.dump(results,
results_file,
ensure_ascii=False,
for_json=True,
use_decimal=True)
# return nonzero status if any warnings or errors are present
# lint infos do not count as failures
n_errors = len(results["errors"]) + len(results["lint_errors"])
n_warnings = len(results["warnings"]) + len(results["lint_warnings"])
if n_errors > 0 or n_warnings > 0:
log.info("Found %d lint errors and %d lint warnings", n_errors,
n_warnings)
sys.exit(1)
log.info("Lint logfile parsed succesfully")
sys.exit(0)
if __name__ == "__main__":
main()

151
vendor/lowrisc_ip/lint/tools/verilator/parse-lint-report.py vendored
View file

@ -1,151 +0,0 @@
#!/usr/bin/env python3
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
r"""Parses lint report and dump filtered messages in hjson format.
"""
import argparse
import logging as log
import re
import sys
from collections import OrderedDict
from pathlib import Path
import hjson
def extract_messages(str_buffer, patterns):
'''Extract messages matching patterns from str_buffer as a dictionary.
The patterns argument is a list of pairs, (key, pattern). Each pattern is a regex
and all matches in str_buffer are stored in a dictionary under the paired key.
'''
results = OrderedDict()
for key, pattern in patterns:
val = results.setdefault(key, [])
val += re.findall(pattern, str_buffer, flags=re.MULTILINE)
return results
def parse_lint_log(str_buffer):
'''Parse error, warnings, and failed properties from the log file'''
err_warn_patterns = {
# If lint warnings have been found, the lint tool will exit
# with a nonzero status code and fusesoc will always spit out
# an error like
#
# ERROR: Failed to build ip:core:name:0.1 : 'make' exited with an error code
#
# If we found any other warnings or errors, there's no point in
# listing this too. BUT we want to make sure we *do* see this
# error if there are no other errors or warnings, since that
# shows something has come unstuck. (Probably the lint tool
# spat out a warning that we don't understand)
("fusesoc-error",
r"^ERROR: Failed to build .* 'make' exited with an error code"),
("errors",
r"^(?!ERROR: Failed to build .* 'make' exited with an error code)ERROR: .*"
),
("errors",
# This is a redundant Verilator error that we ignore, since we
# already parse out each individual error.
r"^(?!%Error: Exiting due to .* warning.*)%Error: .*"),
# TODO(https://github.com/olofk/edalize/issues/90):
# this is a workaround until we actually have native Edalize
# support for JasperGold and "formal" targets
("warnings",
r"^(?!WARNING: Unknown item formal in section Target)WARNING: .*"),
("warnings", r"^%Warning: .* "),
("lint_errors", r"^%Error-.*"),
("lint_warnings", r"^%Warning-.*"),
}
return extract_messages(str_buffer, err_warn_patterns)
def get_results(logpath):
'''Parse Lint log file and extract info to a dictionary'''
results = {
"tool": "verilator",
"fusesoc-error": [],
"errors": [],
"warnings": [],
"lint_errors": [],
"lint_warnings": [],
"lint_infos": []
}
try:
with Path(logpath).open() as f:
str_buffer = f.read()
results = parse_lint_log(str_buffer)
except IOError as err:
results["errors"] += ["IOError: %s" % err]
# If there are no errors or warnings, add the "fusesoc-error" field to
# "errors" (which will be reported as tooling errors). Remove the
# "fusesoc-error" field either way.
if not (results['errors'] or results['warnings']):
results['errors'] = results['fusesoc-error']
del results['fusesoc-error']
return results
def main():
parser = argparse.ArgumentParser(
description="""This script parses verible lint log files from
a lint run, filters the messages and creates an aggregated result
.hjson file with the following fields:
{"tool": "verilator",
"errors" : [],
"warnings" : [],
"lint_errors" : [],
"lint_warnings" : [],
"lint_infos" : []}
The fields 'errors' and 'warnings' contain file IO messages or
messages output by the tool itself, whereas the fields prefixed with
'lint_' contain lint-related messages.
The script returns nonzero status if any warnings or errors are present.
""")
parser.add_argument('--logpath',
type=str,
default="verilator.log",
help=('FPV log file path. Defaults to `lint.log` '
'under the current script directory.'))
parser.add_argument(
'--reppath',
type=str,
default="results.hjson",
help=('Parsed output hjson file path. Defaults to '
'`results.hjson` under the current script directory.'))
args = parser.parse_args()
results = get_results(args.logpath)
with Path(args.reppath).open("w") as results_file:
hjson.dump(results,
results_file,
ensure_ascii=False,
for_json=True,
use_decimal=True)
# return nonzero status if any warnings or errors are present
# lint infos do not count as failures
n_errors = len(results["errors"]) + len(results["lint_errors"])
n_warnings = len(results["warnings"]) + len(results["lint_warnings"])
if n_errors > 0 or n_warnings > 0:
log.info("Found %d lint errors and %d lint warnings", n_errors,
n_warnings)
sys.exit(1)
log.info("Lint logfile parsed succesfully")
sys.exit(0)
if __name__ == "__main__":
main()

240
vendor/lowrisc_ip/util/dvsim/LintCfg.py vendored
View file

@ -1,42 +1,50 @@
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
r"""
r'''
Class describing lint configuration object
"""
'''
import hjson
import logging as log
from pathlib import Path
from tabulate import tabulate
from OneShotCfg import OneShotCfg
from utils import VERBOSE, print_msg_list, subst_wildcards
from utils import subst_wildcards, check_bool
from MsgBuckets import MsgBuckets
class LintCfg(OneShotCfg):
"""Derivative class for linting purposes.
"""
'''Derivative class for linting purposes.'''
flow = 'lint'
def __init__(self, flow_cfg_file, hjson_data, args, mk_config):
# This is a lint-specific attribute
self.is_style_lint = ""
# TODO: check whether this can be replaced with the subflow concept.
# This determines whether the flow is for a style lint run.
# Format: bool
self.is_style_lint = ''
# Determines which message severities to print into report summaries
# Format: [str, ...]
self.report_severities = []
# Determines which message severities lead to a pass/fail
# Format: [str, ...]
self.fail_severities = []
# Message bucket format configuration
# Format: [{category: str, severity: str, label: str}, ...]
self.message_buckets = []
super().__init__(flow_cfg_file, hjson_data, args, mk_config)
# Convert to boolean
if self.is_style_lint == "True":
self.is_style_lint = True
else:
self.is_style_lint = False
# Convert to boolean if needed.
self.is_style_lint = check_bool(self.is_style_lint)
# Set the title for lint results.
if self.is_style_lint:
self.results_title = self.name.upper() + " Style Lint Results"
self.results_title = f'{self.name.upper()} Style Lint Results'
else:
self.results_title = self.name.upper() + " Lint Results"
self.results_title = f'{self.name.upper()} Lint Results'
def gen_results_summary(self):
'''
@ -44,177 +52,127 @@ class LintCfg(OneShotCfg):
'''
# Generate results table for runs.
log.info("Create summary of lint results")
log.info('Create summary of lint results')
results_str = "## " + self.results_title + " (Summary)\n\n"
results_str += "### " + self.timestamp_long + "\n"
results_str = f'## {self.results_title} (Summary)\n\n'
results_str += f'### {self.timestamp_long}\n'
if self.revision:
results_str += "### " + self.revision + "\n"
results_str += "### Branch: " + self.branch + "\n"
results_str += "\n"
results_str += f'### {self.revision}\n'
results_str += f'### Branch: {self.branch}\n'
results_str += '\n'
header = [
"Name", "Tool Warnings", "Tool Errors", "Lint Warnings",
"Lint Errors"
]
colalign = ("center", ) * len(header)
# Aggregate with all summaries
self.totals = MsgBuckets(self.message_buckets)
for cfg in self.cfgs:
self.totals += cfg.result_summary
# Construct Header
labels = self.totals.get_labels(self.report_severities)
header = ['Name'] + labels
colalign = ('center', ) * len(header)
table = [header]
keys = self.totals.get_keys(self.report_severities)
for cfg in self.cfgs:
results_page = cfg.results_server_dir + '/results.html'
results_page = f'{cfg.results_server_dir}/results.html'
results_page_url = results_page.replace(
cfg.results_server_prefix, cfg.results_server_url_prefix)
name_with_link = "[" + cfg.name.upper(
) + "](" + results_page_url + ")"
table.append([
name_with_link,
str(len(cfg.result_summary["warnings"])) + " W",
str(len(cfg.result_summary["errors"])) + " E",
str(len(cfg.result_summary["lint_warnings"])) + " W",
str(len(cfg.result_summary["lint_errors"])) + " E"
])
name_with_link = f'[{cfg.name.upper()}]({results_page_url})'
row = [name_with_link]
row += cfg.result_summary.get_counts_md(keys)
table.append(row)
if len(table) > 1:
self.results_summary_md = results_str + tabulate(
table, headers="firstrow", tablefmt="pipe",
colalign=colalign) + "\n"
table, headers='firstrow', tablefmt='pipe',
colalign=colalign) + '\n'
else:
self.results_summary_md = results_str + "\nNo results to display.\n"
self.results_summary_md = f'{results_str}\nNo results to display.\n'
print(self.results_summary_md)
# Return only the tables
return self.results_summary_md
# TODO(#9079): This way of parsing out messages into an intermediate
# results.hjson file will be replaced by a native parser mechanism.
def _gen_results(self, results):
# '''
# The function is called after the regression has completed. It looks
# for a regr_results.hjson file with aggregated results from the lint run.
# The hjson needs to have the following (potentially empty) fields
# for a results.hjson file with aggregated results from the lint run.
# The hjson needs to have the following format:
#
# {
# tool: ""
# errors: []
# warnings: []
# lint_errors: []
# lint_warning: []
# lint_infos: []
# bucket_key: [str],
# // other buckets according to message_buckets configuration
# }
#
# where each entry is a string representing a lint message. This allows
# to reuse the same LintCfg class with different tools since just the
# parsing script that transforms the tool output into the hjson above
# needs to be adapted.
# Each bucket key points to a list of signatures (strings).
# The bucket categories and severities are defined in the
# message_buckets class variable, and can be set via Hjson Dvsim
# config files.
#
# note that if this is a primary config, the results will
# Note that if this is a primary config, the results will
# be generated using the _gen_results_summary function
# '''
# Generate results table for runs.
results_str = "## " + self.results_title + "\n\n"
results_str += "### " + self.timestamp_long + "\n"
results_str = f'## {self.results_title}\n\n'
results_str += f'### {self.timestamp_long}\n'
if self.revision:
results_str += "### " + self.revision + "\n"
results_str += "### Branch: " + self.branch + "\n"
results_str += "### Lint Tool: " + self.tool.upper() + "\n\n"
results_str += f'### {self.revision}\n'
results_str += f'### Branch: {self.branch}\n'
results_str += f'### Tool: {self.tool.upper()}\n\n'
header = [
"Build Mode", "Tool Warnings", "Tool Errors", "Lint Warnings",
"Lint Errors"
]
colalign = ("center", ) * len(header)
table = [header]
# aggregated counts
self.result_summary["warnings"] = []
self.result_summary["errors"] = []
self.result_summary["lint_warnings"] = []
self.result_summary["lint_errors"] = []
fail_msgs = ""
# Load all result files from all build modes and convert them to
# message buckets.
self.result = []
self.result_summary = MsgBuckets(self.message_buckets)
for mode in self.build_modes:
result_data = Path(
subst_wildcards(self.build_dir, {"build_mode": mode.name}) +
result_path = Path(
subst_wildcards(self.build_dir, {'build_mode': mode.name}) +
'/results.hjson')
log.info("[results:hjson]: [%s]: [%s]", self.name, result_data)
log.info('[results:hjson]: [%s]: [%s]', self.name, result_path)
# TODO(#9079): replace this with native log parser
msgs = MsgBuckets(self.message_buckets)
msgs.load_hjson(result_path)
self.result.append(msgs)
# Aggregate with summary results
self.result_summary += msgs
try:
with result_data.open() as results_file:
self.result = hjson.load(results_file, use_decimal=True)
except IOError as err:
log.warning("%s", err)
self.result = {
"tool": "",
"errors": ["IOError: %s" % err],
"warnings": [],
"lint_errors": [],
"lint_warnings": [],
"lint_infos": []
}
if self.result:
table.append([
mode.name,
str(len(self.result["warnings"])) + " W ",
str(len(self.result["errors"])) + " E",
# We currently do not publish these infos at
# the moment len(self.result["lint_infos"]),
str(len(self.result["lint_warnings"])) + " W",
str(len(self.result["lint_errors"])) + " E"
])
else:
self.result = {
"tool": "",
"errors": [],
"warnings": [],
"lint_errors": [],
"lint_warnings": [],
"lint_infos": []
}
self.result_summary["warnings"] += self.result["warnings"]
self.result_summary["errors"] += self.result["errors"]
self.result_summary["lint_warnings"] += self.result[
"lint_warnings"]
self.result_summary["lint_errors"] += self.result["lint_errors"]
# Append detailed messages if they exist
hdr_key_pairs = [("Tool Warnings", "warnings"),
("Tool Errors", "errors"),
("Lint Warnings", "lint_warnings"),
("Lint Errors", "lint_errors")]
# Lint fails if any warning or error message has occurred
self.errors_seen = False
for _, key in hdr_key_pairs:
if key in self.result:
if self.result.get(key):
self.errors_seen = True
break
if self.errors_seen:
fail_msgs += "\n### Errors and Warnings for Build Mode `'" + mode.name + "'`\n"
for hdr, key in hdr_key_pairs:
msgs = self.result.get(key)
fail_msgs += print_msg_list("#### " + hdr, msgs, self.max_msg_count)
# Construct Header
labels = self.result_summary.get_labels(self.report_severities)
header = ['Build Mode'] + labels
colalign = ('center', ) * len(header)
table = [header]
fail_msgs = ''
self.errors_seen = 0
keys = self.result_summary.get_keys(self.report_severities)
for mode, res in zip(self.build_modes, self.result):
row = [mode.name] + res.get_counts_md(keys)
table.append(row)
self.errors_seen += res.has_signatures(self.fail_severities)
fail_msgs += f"\n### Messages for Build Mode `'{mode.name}'`\n"
fail_msgs += res.print_signatures_md(self.report_severities,
self.max_msg_count)
if len(table) > 1:
self.results_md = results_str + tabulate(
table, headers="firstrow", tablefmt="pipe",
colalign=colalign) + "\n"
table, headers='firstrow', tablefmt='pipe',
colalign=colalign) + '\n'
# the email and published reports will default to self.results_md if they are
# empty. in case they need to be sanitized, override them and do not append
# detailed messages.
# The email and published reports will default to self.results_md
# if they are empty. In case they need to be sanitized, override
# them and do not append detailed messages.
if self.sanitize_email_results:
self.email_results_md = self.results_md
if self.sanitize_publish_results:
self.publish_results_md = self.results_md
# locally generated result always contains all details
# Locally generated result always contains all details.
self.results_md += fail_msgs
else:
self.results_md = results_str + "\nNo results to display.\n"
self.results_md = f'{results_str}\nNo results to display.\n'
self.email_results_md = self.results_md
self.publish_results_md = self.results_md

86
vendor/lowrisc_ip/util/dvsim/LintParser.py vendored Normal file
View file

@ -0,0 +1,86 @@
#!/usr/bin/env python3
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
r"""Helper class for parsing lint reports into a generic hjson format.
"""
import re
import hjson
from pathlib import Path
from typing import List, Dict, Tuple
# TODO(#9079): this class will be refactored so that it can be integrated into
# the Dvsim core code.
class LintParser():
def __init__(self) -> None:
self.buckets = {
'flow_warning': [],
'flow_error': [],
'lint_info': [],
'lint_warning': [],
'lint_error': [],
# this bucket is temporary and will be removed at the end of the
# parsing pass.
'fusesoc-error': []
}
self.severities = {
'flow_warning': 'warning',
'flow_error': 'error',
'lint_info': 'info',
'lint_warning': 'warning',
'lint_error': 'error',
}
def extract_messages(self, log_content: str, patterns: List[str]) -> None:
"""
This extracts messages from the string buffer log_content.
The argument patterns needs to be a list of tuples with
(<error_severity>, <pattern_to_match_for>).
"""
for bucket, pattern in patterns:
self.buckets[bucket] += \
re.findall(pattern, log_content, flags=re.MULTILINE)
def get_results(self, args: Dict[Path, List[Tuple]]) -> Dict[str, int]:
"""
Parse report and corresponding logfiles and extract error, warning
and info messages for each IP present in the result folder
"""
# Open all log files
for path, patterns in args.items():
try:
with path.open() as f:
log_content = f.read()
self.extract_messages(log_content, patterns)
except IOError as err:
self.buckets['flow_error'] += \
["IOError: %s" % err]
# If there are no errors or warnings, add the "fusesoc-error" field to
# "errors" (which will be reported as tooling errors). Remove the
# "fusesoc-error" field either way.
num_messages = {
'info': 0,
'warning': 0,
'error': 0
}
for key, sev in self.severities.items():
num_messages[sev] += len(self.buckets[key])
if num_messages['error'] == 0 and num_messages['warning'] == 0:
self.buckets['flow_error'] = self.buckets['fusesoc-error']
del self.buckets['fusesoc-error']
return num_messages
def write_results_as_hjson(self, outpath: Path) -> None:
with outpath.open("w") as results_file:
# Construct results dict for Hjson file.
hjson.dump(self.buckets,
results_file,
ensure_ascii=False,
for_json=True,
use_decimal=True)

72
vendor/lowrisc_ip/util/dvsim/MsgBucket.py vendored Normal file
View file

@ -0,0 +1,72 @@
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
r'''
Message bucket class that encapsulates information such as bucket
category, bucket severity, the associated label for the results table, and
a list with message signatures.
'''
import copy
class MsgBucket():
# Known severity levels and color map for Dvsim summary tables.
SEVERITIES = {
'info': 'I',
'review': 'W',
'warning': 'W',
'error': 'E',
'fatal': 'E'
}
@classmethod
def severity_is_known(cls, severity: str) -> bool:
'''Returns true if the severity is known'''
return severity in cls.SEVERITIES
def __init__(self,
category: str,
severity: str,
label: str = None) -> None:
if not MsgBucket.severity_is_known(severity):
RuntimeError(f'Unknown severity {severity}')
self.category = category
self.severity = severity
self.label = f'{category} {severity}s'.title() if not label else label
self.signatures = []
def clear(self) -> None:
'''Clears the signatures list'''
self.signatures = []
def count(self) -> int:
'''Return number of signatures'''
return len(self.signatures)
def count_md(self, colmap: bool = True) -> str:
'''Return count string with optional colormap applied'''
countstr = str(self.count())
if colmap:
countstr += ' ' + self.SEVERITIES[self.severity]
return countstr
def merge(self, other) -> None:
'''Merge other bucket into this one'''
if self.category != other.category:
raise RuntimeError(f'Category {other.category} does not match '
f'{self.category} for bucket {self.label}')
elif self.severity != other.severity:
raise RuntimeError(f'Severity {other.severity} does not match '
f'{self.severity} for bucket {self.label}')
else:
self.signatures.extend(copy.deepcopy(other.signatures))
def __add__(self, other):
'''Merges two message buckets into one'''
mb = copy.deepcopy(self)
mb.merge(other)
return mb

191
vendor/lowrisc_ip/util/dvsim/MsgBuckets.py vendored Normal file
View file

@ -0,0 +1,191 @@
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
r'''
This class holds a dict of message buckets according to the format defined
upon construction. It is meant to hold all message buckets of a build / tool
run, and provides convenience functions that streamline result aggregation
and printout in the Dvsim flow classes.
'''
import hjson
import copy
import logging as log
from pathlib import Path
from typing import Dict, List
from utils import print_msg_list
from MsgBucket import MsgBucket
class MsgBuckets():
def __init__(self,
bucket_cfgs: List[Dict]) -> None:
self.buckets = {f"{b['category']}_{b['severity']}":
MsgBucket(b['category'], b['severity'], b['label'])
for b in bucket_cfgs}
def clear(self):
'''Clear all signatures in all buckets'''
for b in self.buckets.values():
b.clear()
def get_labels(self,
severity_filter: List[str] = []) -> List[str]:
'''
Returns all bucket labels as a list.
If severity_filter is not empty, only the buckets with the listed
severities will be returned.
'''
for s in severity_filter:
if not MsgBucket.severity_is_known(s):
RuntimeError(f'Unknown severity {s}')
labels = []
for key, b in self.buckets.items():
if not severity_filter or b.severity in severity_filter:
labels.append(b.label)
return labels
def get_keys(self,
severity_filter: List[str] = []) -> List[str]:
'''
Returns all bucket keys as a list.
If severity_filter is not empty, only the buckets with the listed
severities will be returned.
'''
for s in severity_filter:
if not MsgBucket.severity_is_known(s):
RuntimeError(f'Unknown severity {s}')
keys = []
for key, b in self.buckets.items():
if not severity_filter or b.severity in severity_filter:
keys.append(key)
return keys
def get_counts(self,
keys: List[str] = None,
severity_filter: List[str] = []) -> List[int]:
'''
Get bucket count totals as a list of integers.
The bucket keys can be supplied externally, in which case the
severity_filter does not apply. If a specific bucket key does not
exist, a 0 count will be returned for that specific key.
If severity_filter is not empty, only the buckets with the listed
severities will be returned.
'''
if not keys:
keys = self.get_keys(severity_filter)
counts = []
for k in keys:
c = self.buckets[k].count() if k in self.buckets else 0
counts.append(c)
return counts
def get_counts_md(self,
keys: List[str] = None,
severity_filter: List[str] = [],
colmap: bool = True) -> List[str]:
'''
Get bucket count totals as a list of strings with optional colormap.
The bucket keys can be supplied externally, in which case the
severity_filter does not apply. If a specific bucket key does not
exist, a "--" string will be returned for that specific key.
If severity_filter is not empty, only the buckets with the listed
severities will be returned.
'''
if not keys:
keys = self.get_keys(severity_filter)
counts = []
for k in keys:
c = self.buckets[k].count_md(colmap) if k in self.buckets else '--'
counts.append(c)
return counts
def has_signatures(self,
severity_filter: List[str] = []) -> bool:
'''
Checks whether there are any signatures with specified severities.
If severity_filter is empty, the method returns true if any of the
buckets contains a nonzero amount of signatures.
'''
return any(self.get_counts(severity_filter=severity_filter))
def print_signatures_md(self,
severity_filter: List[str] = [],
max_per_bucket: int = -1) -> str:
'''
Render signatures into a string buffer.
The bucket labels are used as subtitles in this printout.
If severity_filter is not empty, only the buckets with the listed
severities will be returned.
The number of messages printed per bucket can be limited by
setting max_per_bucket to a nonnegative value.
'''
msgs = ''
keys = self.get_keys(severity_filter)
for k in keys:
msgs += print_msg_list(f'#### {self.buckets[k].label}',
self.buckets[k].signatures,
max_per_bucket)
return msgs
def merge(self, other) -> None:
'''
Merge other MsgBuckets object into this one.
This will append signatures to the corresponding bucket if it exists.
If the bucket does not yet exist it will be created.
'''
for k, b in other.buckets.items():
if k in self.buckets:
self.buckets[k].merge(b)
else:
self.buckets.update({k: copy.deepcopy(b)})
def __add__(self, other):
'''
Merges two MsgBucket objects into one.
Buckets will be uniquified, and signatures in buckets with the same
category and severity will be merged.
'''
mb = copy.deepcopy(self)
mb.merge(other)
return mb
# TODO(#9079): remove the method below once the log parsing has been
# merged into the Dvsim core code.
def load_hjson(self, result_path: Path) -> None:
'''Clear internal data structure and initialize with values in Hjson'''
self.clear()
try:
with result_path.open() as results_file:
results_dict = hjson.load(results_file, use_decimal=True)
except IOError as err:
log.warning("%s", err)
if 'flow_error' not in self.buckets:
self.buckets.update({'flow_error': MsgBucket('flow',
'error')})
self.buckets['flow_error'].signatures.append('IOError: %s' % err)
return
for k, signatures in results_dict.items():
if not isinstance(signatures, List):
raise RuntimeError(f'Signatures in {k} must be a '
'list of strings')
self.buckets[k].signatures.extend(signatures)

106
vendor/lowrisc_ip/util/dvsim/ascentlint-report-parser.py vendored Executable file
View file

@ -0,0 +1,106 @@
#!/usr/bin/env python3
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
r"""Parses lint report and dump filtered messages in hjson format.
"""
import argparse
import logging as log
import sys
from pathlib import Path
from LintParser import LintParser
# TODO(#9079): this script will be removed long term once the
# parser has been merged with the Dvsim core code.
def main():
parser = argparse.ArgumentParser(
description="""This script parses AscentLint log and report files from
a lint run, filters the messages and creates an aggregated result
.hjson file with lint messages and their severities.
The script returns nonzero status if any warnings or errors are
present.
""")
parser.add_argument('--repdir',
type=lambda p: Path(p).resolve(),
default="./",
help="""The script searches the 'ascentlint.log' and
'ascentlint.rpt' files in this directory.
Defaults to './'""")
parser.add_argument('--outfile',
type=lambda p: Path(p).resolve(),
default="./results.hjson",
help="""Path to the results Hjson file.
Defaults to './results.hjson'""")
args = parser.parse_args()
# Define warning/error patterns for each logfile
parser_args = {}
# Patterns for lint.log
parser_args.update({
args.repdir.joinpath('ascentlint.log'): [
# If lint warnings have been found, the lint tool will exit
# with a nonzero status code and fusesoc will always spit out
# an error like
#
# ERROR: Failed to build ip:core:name:0.1 : 'make' exited with an error code
#
# If we found any other warnings or errors, there's no point in
# listing this too. BUT we want to make sure we *do* see this
# error if there are no other errors or warnings, since that
# shows something has come unstuck. (Probably the lint tool
# spat out a warning that we don't understand)
("fusesoc-error",
r"^ERROR: Failed to build .* : 'make' exited with an error code")
]
})
# Patterns for ascentlint.log
parser_args.update({
args.repdir.joinpath('lint-ascentlint/ascentlint.log'): [
("flow_error", r"^FlexNet Licensing error.*"),
("flow_error", r"^Error: .*"),
("flow_error", r"^ERROR.*"),
("flow_error", r"^ ERR .*"),
("flow_warning", r"^Warning: .*"),
# TODO: struct assignment labels within concatenation
# not supported. check with newer ascentlint version.
("flow_warning", r"^ (?!WARN \[#39024\])WARN .*")
]
})
# Patterns for ascentlint.rpt
parser_args.update({
args.repdir.joinpath('lint-ascentlint/ascentlint.rpt'): [
("lint_error", r"^E .*"),
("lint_warning", r"^W .*"),
("lint_info", r"^I .*")
]
})
# Parse logs
parser = LintParser()
num_messages = parser.get_results(parser_args)
# Write out results file
parser.write_results_as_hjson(args.outfile)
# return nonzero status if any warnings or errors are present
# lint infos do not count as failures
if num_messages['error'] > 0 or num_messages['warning'] > 0:
log.info("Found %d lint errors and %d lint warnings",
num_messages['error'],
num_messages['warning'])
sys.exit(1)
log.info("Lint logfile parsed succesfully")
sys.exit(0)
if __name__ == "__main__":
main()

29
vendor/lowrisc_ip/util/dvsim/utils.py vendored
View file

@ -415,7 +415,7 @@ def htmc_color_pc_cells(text):
fp_patterns = r"[\+\-]?\d+\.?\d*"
patterns = fp_patterns + '|' + na_list_patterns
indicators = "%|%u|G|B|E|W|EN|WN"
indicators = "%|%u|G|B|E|W|I|EN|WN"
match = re.findall(
r"(<td.*>\s*(" + patterns + r")\s+(" + indicators + r")\s*</td>)",
text)
@ -476,6 +476,9 @@ def htmc_color_pc_cells(text):
# Bad: red
elif indicator == "B":
subst = color_cell(cell, "c0", indicator)
# Info, uncolored.
elif indicator == "I":
subst = cell.replace("I", "")
# Bad if positive: red for errors, yellow for warnings,
# otherwise green.
elif indicator in ["E", "W"]:
@ -612,3 +615,27 @@ def clean_odirs(odir, max_odirs, ts_format=TS_FORMAT):
shutil.rmtree(old, ignore_errors=True)
return [] if max_odirs == 0 else dirs[:max_odirs - 1]
def check_bool(x):
"""check_bool checks if input 'x' either a bool or
one of the following strings: ["true", "false"]
It returns value as Bool type.
"""
if isinstance(x, bool):
return x
if not x.lower() in ["true", "false"]:
raise RuntimeError("{} is not a boolean value.".format(x))
else:
return (x.lower() == "true")
def check_int(x):
"""check_int checks if input 'x' is decimal integer.
It returns value as an int type.
"""
if isinstance(x, int):
return x
if not x.isdecimal():
raise RuntimeError("{} is not a decimal number".format(x))
return int(x)

91
vendor/lowrisc_ip/util/dvsim/veriblelint-report-parser.py vendored Executable file
View file

@ -0,0 +1,91 @@
#!/usr/bin/env python3
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
r"""Parses lint report and dump filtered messages in hjson format.
"""
import argparse
import logging as log
import sys
from pathlib import Path
from LintParser import LintParser
# TODO(#9079): this script will be removed long term once the
# parser has been merged with the Dvsim core code.
def main():
parser = argparse.ArgumentParser(
description="""This script parses Verible Lint log and report files from
a lint run, filters the messages and creates an aggregated result
.hjson file with lint messages and their severities.
The script returns nonzero status if any warnings or errors are
present.
""")
parser.add_argument('--repfile',
type=lambda p: Path(p).resolve(),
default="./verilator.log'",
help="""The script searches the log file provided.
Defaults to './verilator.log'""")
parser.add_argument('--outfile',
type=lambda p: Path(p).resolve(),
default="./results.hjson",
help="""Path to the results Hjson file.
Defaults to './results.hjson'""")
args = parser.parse_args()
# Patterns for lint.log
parser_args = {
args.repfile: [
# If lint warnings have been found, the lint tool will exit
# with a nonzero status code and fusesoc will always spit out
# an error like
#
# ERROR: Failed to run ip:core:name:0.1 : Lint failed
#
# If we found any other warnings or errors, there's no point in
# listing this too. BUT we want to make sure we *do* see this
# error if there are no other errors or warnings, since that
# shows something has come unstuck. (Probably the lint tool
# spat out a warning that we don't understand)
("fusesoc-error", r"^ERROR: Failed to run .*: Lint failed.*"),
("flow_error", r"^(?!ERROR: Failed to run .* Lint failed)ERROR: .*"),
("flow_error", r"^.*Error: .*"),
("flow_error", r"^E .*"),
("flow_error", r"^F .*"),
("flow_error", r".*: syntax error, rejected.*"),
# TODO(https://github.com/olofk/edalize/issues/90):
# this is a workaround until we actually have native Edalize
# support for JasperGold and "formal" targets
("flow_warning",
r"^(?!WARNING: Unknown item formal in section Target)WARNING: .*"),
("flow_warning", r"^.*Warning: .* "),
("flow_warning", r"^W .*"),
("lint_warning", r"^.*\[Style:.*")
]
}
# Parse logs
parser = LintParser()
num_messages = parser.get_results(parser_args)
# Write out results file
parser.write_results_as_hjson(args.outfile)
# return nonzero status if any warnings or errors are present
# lint infos do not count as failures
if num_messages['error'] > 0 or num_messages['warning'] > 0:
log.info("Found %d lint errors and %d lint warnings",
num_messages['error'],
num_messages['warning'])
sys.exit(1)
log.info("Lint logfile parsed succesfully")
sys.exit(0)
if __name__ == "__main__":
main()

94
vendor/lowrisc_ip/util/dvsim/verilator-report-parser.py vendored Executable file
View file

@ -0,0 +1,94 @@
#!/usr/bin/env python3
# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0
r"""Parses lint report and dump filtered messages in hjson format.
"""
import argparse
import logging as log
import sys
from pathlib import Path
from LintParser import LintParser
# TODO(#9079): this script will be removed long term once the
# parser has been merged with the Dvsim core code.
def main():
parser = argparse.ArgumentParser(
description="""This script parses Verilator lint log and report files
from a lint run, filters the messages and creates an aggregated result
.hjson file with lint messages and their severities.
The script returns nonzero status if any warnings or errors are
present.
""")
parser.add_argument('--repfile',
type=lambda p: Path(p).resolve(),
default="./verilator.log'",
help="""The script searches the log file provided.
Defaults to './verilator.log'""")
parser.add_argument('--outfile',
type=lambda p: Path(p).resolve(),
default="./results.hjson",
help="""Path to the results Hjson file.
Defaults to './results.hjson'""")
args = parser.parse_args()
# Patterns for lint.log
parser_args = {
args.repfile: [
# If lint warnings have been found, the lint tool will exit
# with a nonzero status code and fusesoc will always spit out
# an error like
#
# ERROR: Failed to build ip:core:name:0.1 : 'make' exited with an error code
#
# If we found any other warnings or errors, there's no point in
# listing this too. BUT we want to make sure we *do* see this
# error if there are no other errors or warnings, since that
# shows something has come unstuck. (Probably the lint tool
# spat out a warning that we don't understand)
("fusesoc-error",
r"^ERROR: Failed to build .* 'make' exited with an error code"),
("flow_error",
r"^(?!ERROR: Failed to build .* 'make' exited with an error code)ERROR: .*"
),
("flow_error",
# This is a redundant Verilator error that we ignore, since we
# already parse out each individual error.
r"^(?!%Error: Exiting due to .* warning.*)%Error: .*"),
# TODO(https://github.com/olofk/edalize/issues/90):
# this is a workaround until we actually have native Edalize
# support for JasperGold and "formal" targets
("flow_warning",
r"^(?!WARNING: Unknown item formal in section Target)WARNING: .*"),
("flow_warning", r"^%Warning: .* "),
("lint_error", r"^%Error-.*"),
("lint_warning", r"^%Warning-.*")
]
}
# Parse logs
parser = LintParser()
num_messages = parser.get_results(parser_args)
# Write out results file
parser.write_results_as_hjson(args.outfile)
# return nonzero status if any warnings or errors are present
# lint infos do not count as failures
if num_messages['error'] > 0 or num_messages['warning'] > 0:
log.info("Found %d lint errors and %d lint warnings",
num_messages['error'],
num_messages['warning'])
sys.exit(1)
log.info("Lint logfile parsed succesfully")
sys.exit(0)
if __name__ == "__main__":
main()