[rom_ctrl, test] rom_ctrl smoketest added

 * new testcase implemented among top level sw tests
 * the new test reads the compile time initialized ROM values
 * if any comparision fails (expected values differs from read value)
   test is terminated with an error

Author: KolosKoblasz-Semify

sw/device/lib/hal/CMakeLists.txt

@@ -2,6 +2,6 @@
 # Licensed under the Apache License, Version 2.0, see LICENSE for details.
 # SPDX-License-Identifier: Apache-2.0
 
-set(SRCS clkmgr.c gpio.c i2c.c mailbox.c mocha.c plic.c rstmgr.c spi_device.c timer.c uart.c)
+set(SRCS clkmgr.c gpio.c i2c.c mailbox.c mocha.c plic.c rstmgr.c spi_device.c timer.c uart.c rom_ctrl.c)
 
 mocha_add_library(NAME hal LIBRARIES SOURCES ${SRCS})

sw/device/lib/hal/mocha.c

@@ -11,11 +11,13 @@
 #include <cheriintrin.h>
 #endif /* defined(__riscv_zcherihybrid) */
 
+static const uintptr_t rom_base = 0x80000ul;
 static const uintptr_t mailbox_base = 0x20010000ul;
 static const uintptr_t dv_test_status_base = 0x20020000ul;
 static const uintptr_t gpio_base = 0x40000000ul;
 static const uintptr_t clkmgr_base = 0x40020000ul;
 static const uintptr_t rstmgr_base = 0x40030000ul;
+static const uintptr_t rom_ctrl_base = 0x40050000ul;
 static const uintptr_t uart_base = 0x41000000ul;
 static const uintptr_t i2c_base = 0x42000000ul;
 static const uintptr_t spi_device_base = 0x43000000ul;
@@ -42,6 +44,15 @@ static void *create_mmio_capability(uintptr_t address, size_t length)
 }
 #endif /* defined(__riscv_zcherihybrid) */
 
+rom_t mocha_system_rom(void)
+{
+#if defined(__riscv_zcherihybrid)
+    return (uart_t)create_mmio_capability(rom_base, 0x48u);
+#else /* !defined(__riscv_zcherihybrid) */
+    return (uart_t)rom_base;
+#endif /* defined(__riscv_zcherihybrid) */
+}
+
 mailbox_t mocha_system_mailbox(void)
 {
 #if defined(__riscv_zcherihybrid)
@@ -78,6 +89,15 @@ rstmgr_t mocha_system_rstmgr(void)
 #endif /* defined(__riscv_zcherihybrid) */
 }
 
+rom_ctrl_t mocha_system_rom_ctrl(void)
+{
+#if defined(__riscv_zcherihybrid)
+    return (rom_ctrl_t)create_mmio_capability(rom_ctrl_base, 0x48u);
+#else /* !defined(__riscv_zcherihybrid) */
+    return (rom_ctrl_t)rom_ctrl_base;
+#endif /* defined(__riscv_zcherihybrid) */
+}
+
 uart_t mocha_system_uart(void)
 {
 #if defined(__riscv_zcherihybrid)

sw/device/lib/hal/mocha.h

@@ -10,6 +10,7 @@
 #include "hal/gpio.h"
 #include "hal/i2c.h"
 #include "hal/mailbox.h"
+#include "hal/rom_ctrl.h"
 #include "hal/plic.h"
 #include "hal/rstmgr.h"
 #include "hal/spi_device.h"
@@ -29,6 +30,8 @@ gpio_t mocha_system_gpio(void);
 clkmgr_t mocha_system_clkmgr(void);
 rstmgr_t mocha_system_rstmgr(void);
 uart_t mocha_system_uart(void);
+rom_t mocha_system_rom(void);
+rom_ctrl_t mocha_system_rom_ctrl(void);
 i2c_t mocha_system_i2c(void);
 spi_device_t mocha_system_spi_device(void);
 timer_t mocha_system_timer(void);

sw/device/lib/hal/rom_ctrl.c

@@ -0,0 +1,19 @@
+// Copyright lowRISC contributors (COSMIC project).
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+#include "hal/rom_ctrl.h"
+#include "hal/mmio.h"
+#include "hal/mocha.h"
+#include <stdint.h>
+
+/* Read specific word_idx-th word from ROM memory */
+uint32_t read_rom(rom_t rom, uint8_t word_idx)
+{
+    uint32_t res;
+
+    res = DEV_READ(rom + 4*word_idx);
+
+    return res;
+}
+

sw/device/lib/hal/rom_ctrl.h

@@ -0,0 +1,20 @@
+// Copyright lowRISC contributors (COSMIC project).
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define ROM_CTRL_REG  (0x0)
+#define FATAL_ALERT_CAUSE (0x4)
+
+typedef void *rom_ctrl_t;
+typedef void *rom_t;
+
+#define ROM_CTRL_FROM_BASE_ADDR(addr) ((rom_ctrl_t)(addr))
+#define ROM_FROM_BASE_ADDR(addr) ((rom_t)(addr))
+
+uint32_t read_rom(rom_t rom, uint8_t word_idx);
+

sw/device/tests/CMakeLists.txt

@@ -18,3 +18,4 @@ mocha_add_test(NAME tag_controller_tag_test SOURCES tag_controller/tag_test.c LI
 mocha_add_test(NAME timer_smoketest SOURCES timer/smoketest.c LIBRARIES ${LIBS} FPGA)
 mocha_add_test(NAME timer_interrupt_test SOURCES timer/interrupt.c LIBRARIES ${LIBS})
 mocha_add_test(NAME uart_smoketest SOURCES uart/smoketest.c LIBRARIES ${LIBS})
+mocha_add_test(NAME rom_ctrl_smoketest SOURCES rom_ctrl/smoketest.c LIBRARIES ${LIBS})

sw/device/tests/rom_ctrl/mem_init_file.vmem

@@ -0,0 +1,17 @@
+@00000000
+DEADBEEF
+CAFEBABE
+00000000
+00000001
+FFFFFFFF
+EEEEEEEE
+01234567
+10000001
+20000002
+30000003
+40000004
+50000005
+F000000F
+0EEEEEE0
+0FFFFFF0
+01010101

sw/device/tests/rom_ctrl/smoketest.c

@@ -0,0 +1,70 @@
+// Copyright lowRISC contributors (COSMIC project).
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+#include "hal/rom_ctrl.h"
+#include "hal/uart.h"
+#include "runtime/print.h"
+#include "hal/mmio.h"
+#include "hal/mocha.h"
+#include <stdbool.h>
+#include <stdint.h>
+
+// Check ROM init values
+static bool rom_read_test(rom_t rom, uart_t console)
+{
+    uint32_t data;
+    uint8_t  rom_length = 16;
+
+    // ROM Init values
+    const uint32_t expected[] = {
+        0xDEADBEEF,
+        0xCAFEBABE,
+        0x00000000,
+        0x00000001,
+        0xFFFFFFFF,
+        0xEEEEEEEE,
+        0x01234567,
+        0x10000001,
+        0x20000002,
+        0x30000003,
+        0x40000004,
+        0x50000005,
+        0xF000000F,
+        0x0EEEEEE0,
+        0x0FFFFFF0,
+        0x01010101
+    };
+
+    uprintf(console, "\nRead ROM!\n");
+
+    // Reading and comparing
+    for (uint8_t word_idx = 0; word_idx < rom_length; word_idx++) {
+       data = read_rom(rom, word_idx);
+       uprintf(console, "data[%lx]:", (unsigned long)(uintptr_t)(rom + 4*word_idx));
+       uprintf(console, "0x%x\n", data);
+
+        if (expected[word_idx] != data) {
+            uprintf(console, "ROM Content mismatch Error.\n");
+            uprintf(console, "Expected: 0x%x\n", expected[word_idx]);
+            uprintf(console, "Terminating ROM CTRL read test.\n");
+
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool test_main()
+{
+    rom_t  rom = mocha_system_rom();
+    uart_t console = mocha_system_uart();
+    bool   read_test_res;
+
+    uart_init(console);
+
+    read_test_res  = rom_read_test(rom, console);
+
+    return read_test_res;
+}