From 7a45a096a5616e89288e58a78f0ea2d80f4c81cf Mon Sep 17 00:00:00 2001 From: Tim Edwards Date: Wed, 29 Dec 2021 11:24:17 -0500 Subject: [PATCH] Added a testbench that exercises the SRAM 2nd (read-only) port, as it was configured for the caravel_pico SoC, with the housekeeping SPI able to access the upper 256-word section of the memory if the CSB bit in the housekeeping control register is cleared. This testbench tests both access through housekeeping and access directly from the SoC through the memory-mapped address. --- verilog/dv/caravel/mgmt_soc/sram_ro/Makefile | 92 +++++++++ verilog/dv/caravel/mgmt_soc/sram_ro/sram_ro.c | 137 +++++++++++++ .../dv/caravel/mgmt_soc/sram_ro/sram_ro_tb.v | 189 ++++++++++++++++++ 3 files changed, 418 insertions(+) create mode 100644 verilog/dv/caravel/mgmt_soc/sram_ro/Makefile create mode 100644 verilog/dv/caravel/mgmt_soc/sram_ro/sram_ro.c create mode 100644 verilog/dv/caravel/mgmt_soc/sram_ro/sram_ro_tb.v diff --git a/verilog/dv/caravel/mgmt_soc/sram_ro/Makefile b/verilog/dv/caravel/mgmt_soc/sram_ro/Makefile new file mode 100644 index 00000000..2ed6d631 --- /dev/null +++ b/verilog/dv/caravel/mgmt_soc/sram_ro/Makefile @@ -0,0 +1,92 @@ +# SPDX-FileCopyrightText: 2020 Efabless Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# SPDX-License-Identifier: Apache-2.0 + +PDK_PATH = $(PDK_ROOT)/sky130A +VERILOG_PATH = ../../../.. +RTL_PATH = $(VERILOG_PATH)/rtl +BEHAVIOURAL_MODELS = ../../ +RISCV_TYPE ?= rv32imc + +FIRMWARE_PATH = ../.. +GCC_PATH?=/ef/apps/bin +GCC_PREFIX?=riscv32-unknown-elf + +SIM_DEFINES = -DFUNCTIONAL -DSIM + +SIM?=RTL + +.SUFFIXES: + +PATTERN = sram_ro + +# Path to management SoC wrapper repository +MGMT_CORE_PATH ?= ~/gits/caravel_pico +ifeq ($(SIM),RTL) + MGMT_WRAPPER_PATH = $(MGMT_CORE_PATH)/verilog/rtl +else + MGMT_WRAPPER_PATH = $(MGMT_CORE_PATH)/verilog +endif + +all: ${PATTERN:=.vcd} + +hex: ${PATTERN:=.hex} + +%.vvp: %_tb.v %.hex +ifeq ($(SIM),RTL) + iverilog -Ttyp $(SIM_DEFINES) -I $(BEHAVIOURAL_MODELS) \ + -I $(PDK_PATH) -I $(RTL_PATH) -I $(MGMT_WRAPPER_PATH) \ + $< -o $@ +else + iverilog -Ttyp $(SIM_DEFINES) -DGL -I $(BEHAVIOURAL_MODELS) \ + -I $(PDK_PATH) -I $(VERILOG_PATH) -I $(RTL_PATH) -I $(MGMT_WRAPPER_PATH) \ + $< -o $@ +endif + +%.vcd: %.vvp + vvp $< + +%.elf: %.c $(FIRMWARE_PATH)/sections.lds $(FIRMWARE_PATH)/start.s check-env + ${GCC_PATH}/${GCC_PREFIX}-gcc -march=$(RISCV_TYPE) -mabi=ilp32 -Wl,-Bstatic,-T,$(FIRMWARE_PATH)/sections.lds,--strip-debug -ffreestanding -nostdlib -o $@ $(FIRMWARE_PATH)/start.s $< + +%.hex: %.elf + ${GCC_PATH}/${GCC_PREFIX}-objcopy -O verilog $< $@ + # to fix flash base address + sed -i 's/@10000000/@00000000/g' $@ + +%.bin: %.elf + ${GCC_PATH}/${GCC_PREFIX}-objcopy -O binary $< /dev/stdout | tail -c +1048577 > $@ + +check-env: +ifndef PDK_ROOT + $(error PDK_ROOT is undefined, please export it before running make) +endif +ifeq (,$(wildcard $(PDK_ROOT)/sky130A)) + $(error $(PDK_ROOT)/sky130A not found, please install pdk before running make) +endif +ifeq (,$(wildcard $(GCC_PATH)/$(GCC_PREFIX)-gcc )) + $(error $(GCC_PATH)/$(GCC_PREFIX)-gcc is not found, please export GCC_PATH and GCC_PREFIX before running make) +endif +# check for efabless style installation +ifeq (,$(wildcard $(PDK_ROOT)/sky130A/libs.ref/*/verilog)) +SIM_DEFINES := ${SIM_DEFINES} -DEF_STYLE +endif +# ---- Clean ---- + +clean: + rm -f *.elf *.hex *.bin *.vvp *.vcd *.log + +.PHONY: clean hex all + diff --git a/verilog/dv/caravel/mgmt_soc/sram_ro/sram_ro.c b/verilog/dv/caravel/mgmt_soc/sram_ro/sram_ro.c new file mode 100644 index 00000000..0f0c0195 --- /dev/null +++ b/verilog/dv/caravel/mgmt_soc/sram_ro/sram_ro.c @@ -0,0 +1,137 @@ +/* + * SPDX-FileCopyrightText: 2020 Efabless Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "../../defs.h" + +#define reg_hkspi_sram_ctrl (*(volatile uint32_t *)0x26100034) +#define reg_hkspi_sram_addr (*(volatile uint32_t *)0x26100030) +#define reg_hkspi_sram_data (*(volatile uint32_t *)0x2610002c) + +// -------------------------------------------------------- + +/* + * SRAM read-only Test + * Tests the read-only port of the dual port SRAM, + * which can be read back through the housekeeping + * module or from the SoC. + */ + +void main() +{ + int i; + + /* Set data out to zero */ + reg_mprj_datal = 0; + + /* Set mprj_io[31:16] to outputs so that we can place values on */ + /* the output pins and check them in the testbench verilog. */ + + reg_mprj_io_31 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_30 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_29 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_28 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_27 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_26 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_25 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_24 = GPIO_MODE_MGMT_STD_OUTPUT; + + reg_mprj_io_23 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_22 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_21 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_20 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_19 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_18 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_17 = GPIO_MODE_MGMT_STD_OUTPUT; + reg_mprj_io_16 = GPIO_MODE_MGMT_STD_OUTPUT; + + /* Apply configuration */ + reg_mprj_xfer = 1; + while (reg_mprj_xfer == 1); + + /* Flag start of test */ + reg_mprj_datal = 0x48000000; + + /* Write to SRAM (reg_rw_block0 = 0x01000000) */ + /* BUT housekeeping RO data is only 256 words at 0x01000400 */ + /* The lower half is accessible by the management SoC */ + (*(volatile uint32_t*)0x01000400) = 0x04030201; + (*(volatile uint32_t*)0x01000404) = 0xaa55aa55; + (*(volatile uint32_t*)0x01000408) = 0x55aa55aa; + (*(volatile uint32_t*)0x0100040c) = 0xcc33cc33; + (*(volatile uint32_t*)0x01000410) = 0xff00ff00; + + /* Read data from housekeeping back-door */ + reg_hkspi_sram_ctrl = 0; /* assert select */ + + /* Note that addressing in this mode is word-wise; */ + /* address 0 in housekeeping = SRAM word address 0x100 */ + /* = SRAM byte address 0x400 = memory-mapped address */ + /* 0x01000400, while address 1 in housekeeping = SRAM */ + /* word address 0x101 = SRAM byte address 0x404 = */ + /* memory-mapped address 0x01000404, and so forth. */ + + reg_hkspi_sram_addr = 0; /* first word address */ + + /* Apply value to output */ + reg_mprj_datal = reg_hkspi_sram_data; + + reg_hkspi_sram_addr = 1; /* next word address */ + + /* Apply value to output */ + reg_mprj_datal = reg_hkspi_sram_data; + + reg_hkspi_sram_addr = 2; /* next word address */ + + /* Apply value to output */ + reg_mprj_datal = reg_hkspi_sram_data; + + reg_hkspi_sram_addr = 3; /* next word address */ + + /* Apply value to output */ + reg_mprj_datal = reg_hkspi_sram_data; + + reg_hkspi_sram_addr = 4; /* next word address */ + + /* Apply value to output */ + reg_mprj_datal = reg_hkspi_sram_data; + + /* Flag end of first test */ + reg_mprj_datal = 0x48010000; + + /* Now do the same thing using the management SoC access only, */ + /* which requires CSB set high */ + + reg_hkspi_sram_ctrl = 1; /* de-assert select */ + + (*(volatile uint32_t*)0x01000000) = 0xff00ff00; + (*(volatile uint32_t*)0x01000004) = 0xcc33cc33; + (*(volatile uint32_t*)0x01000008) = 0x55aa55aa; + (*(volatile uint32_t*)0x0100000c) = 0xaa55aa55; + (*(volatile uint32_t*)0x01000010) = 0x04030201; + + /* Read back from read-only port (note different address block) */ + + reg_mprj_datal = (*(volatile uint32_t*)0x02000000); + reg_mprj_datal = (*(volatile uint32_t*)0x02000004); + reg_mprj_datal = (*(volatile uint32_t*)0x02000008); + reg_mprj_datal = (*(volatile uint32_t*)0x0200000c); + reg_mprj_datal = (*(volatile uint32_t*)0x02000010); + + /* Flag end of second test */ + reg_mprj_datal = 0x48020000; +} + diff --git a/verilog/dv/caravel/mgmt_soc/sram_ro/sram_ro_tb.v b/verilog/dv/caravel/mgmt_soc/sram_ro/sram_ro_tb.v new file mode 100644 index 00000000..104b6ac2 --- /dev/null +++ b/verilog/dv/caravel/mgmt_soc/sram_ro/sram_ro_tb.v @@ -0,0 +1,189 @@ +`default_nettype none +/* + * SPDX-FileCopyrightText: 2017 Clifford Wolf, 2018 Tim Edwards + * + * StriVe - A full example SoC using PicoRV32 in SkyWater s8 + * + * Copyright (C) 2017 Clifford Wolf + * Copyright (C) 2018 Tim Edwards + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * SPDX-License-Identifier: ISC + */ + +`timescale 1 ns / 1 ps + +`include "__uprj_netlists.v" +`include "caravel_netlists.v" +`include "spiflash.v" + +module sram_ro_tb; + + reg clock; + reg power1; + reg power2; + + always #10 clock <= (clock === 1'b0); + + initial begin + clock <= 0; + end + + initial begin + $dumpfile("sram_ro.vcd"); + $dumpvars(0, sram_ro_tb); + + // Repeat cycles of 1000 clock edges as needed to complete testbench + repeat (25) begin + repeat (1000) @(posedge clock); + $display("+1000 cycles"); + end + $display("%c[1;31m",27); + `ifdef GL + $display ("Monitor: Timeout, Test GPIO (GL) Failed"); + `else + $display ("Monitor: Timeout, Test GPIO (RTL) Failed"); + `endif + $display("%c[0m",27); + $finish; + end + + wire [37:0] mprj_io; // Most of these are no-connects + wire [15:0] checkbits; + + assign checkbits = mprj_io[31:16]; + assign mprj_io[3] = 1'b1; // Force CSB high. + + wire flash_csb; + wire flash_clk; + wire flash_io0; + wire flash_io1; + wire gpio; + + reg RSTB; + + // Monitor + initial begin + wait(checkbits == 16'h4800); + `ifdef GL + $display("Monitor: Test R/O SRAM (GL) Started"); + `else + $display("Monitor: Test R/O SRAM (RTL) Started"); + `endif + wait(checkbits == 16'h0403); + wait(checkbits == 16'haa55); + wait(checkbits == 16'h55aa); + wait(checkbits == 16'hcc33); + wait(checkbits == 16'hff00); + wait(checkbits == 16'h4801); + `ifdef GL + $display("Monitor: Test R/O SRAM (GL) Midpoint"); + `else + $display("Monitor: Test R/O SRAM (RTL) Midpoint"); + `endif + + wait(checkbits == 16'hff00); + wait(checkbits == 16'hcc33); + wait(checkbits == 16'h55aa); + wait(checkbits == 16'haa55); + wait(checkbits == 16'h0403); + wait(checkbits == 16'h4802); + `ifdef GL + $display("Monitor: Test R/O SRAM (GL) Passed"); + `else + $display("Monitor: Test R/O SRAM (RTL) Passed"); + `endif + $finish; + end + + initial begin + RSTB <= 1'b0; + + #1000; + RSTB <= 1'b1; // Release reset + #2000; + end + + initial begin // Power-up + power1 <= 1'b0; + power2 <= 1'b0; + #200; + power1 <= 1'b1; + #200; + power2 <= 1'b1; + end + + + always @(checkbits) begin + #1 $display("GPIO state = %b", checkbits); + end + + wire VDD3V3; + wire VDD1V8; + wire VSS; + + assign VDD3V3 = power1; + assign VDD1V8 = power2; + assign VSS = 1'b0; + + // These are the mappings of mprj_io GPIO pads that are set to + // specific functions on startup: + // + // JTAG = mgmt_gpio_io[0] (inout) + // SDO = mgmt_gpio_io[1] (output) + // SDI = mgmt_gpio_io[2] (input) + // CSB = mgmt_gpio_io[3] (input) + // SCK = mgmt_gpio_io[4] (input) + // ser_rx = mgmt_gpio_io[5] (input) + // ser_tx = mgmt_gpio_io[6] (output) + // irq = mgmt_gpio_io[7] (input) + + caravel uut ( + .vddio (VDD3V3), + .vssio (VSS), + .vdda (VDD3V3), + .vssa (VSS), + .vccd (VDD1V8), + .vssd (VSS), + .vdda1 (VDD3V3), + .vdda2 (VDD3V3), + .vssa1 (VSS), + .vssa2 (VSS), + .vccd1 (VDD1V8), + .vccd2 (VDD1V8), + .vssd1 (VSS), + .vssd2 (VSS), + .clock (clock), + .gpio (gpio), + .mprj_io (mprj_io), + .flash_csb(flash_csb), + .flash_clk(flash_clk), + .flash_io0(flash_io0), + .flash_io1(flash_io1), + .resetb (RSTB) + ); + + spiflash #( + .FILENAME("sram_ro.hex") + ) spiflash ( + .csb(flash_csb), + .clk(flash_clk), + .io0(flash_io0), + .io1(flash_io1), + .io2(), // not used + .io3() // not used + ); + +endmodule +`default_nettype wire