sw: update SPI Device HAL to use new autogen interface

Signed-off-by: Alice Ziuziakowska <a.ziuziakowska@lowrisc.org>

Author: ziuziakowska

sw/device/bootrom/CMakeLists.txt

@@ -6,7 +6,7 @@ set(NAME bootrom)
 add_executable(${NAME} bootrom.c data_load.S ../devicetree/mocha.S)
 target_link_libraries(${NAME} hal_vanilla runtime_vanilla startup_vanilla)
 target_compile_options(${NAME} PUBLIC ${VANILLA_FLAGS})
-target_link_options(${NAME} PUBLIC 
+target_link_options(${NAME} PUBLIC
   "-nodefaultlibs"
   "-T${CMAKE_CURRENT_SOURCE_DIR}/rom.ld"
   "-L${LDS_DIR}"

sw/device/bootrom/bootrom.c

@@ -7,6 +7,7 @@
 #include "constants.h"
 #include "hal/gpio.h"
 #include "hal/hart.h"
+#include "hal/mmio.h"
 #include "hal/mocha.h"
 #include "hal/spi_device.h"
 #include "hal/uart.h"
@@ -88,7 +89,7 @@ void boot(uintptr_t addr)
 void clear_slots()
 {
     for (size_t i = 0; i < ARRAY_LEN(boot_slots); i++) {
-        DEV_WRITE(boot_slots[i], 0x00);
+        DEV_WRITE(boot_slots[i], 0);
     }
 }
 
@@ -111,41 +112,41 @@ bool spi_boot_strap(struct boot_context *ctx)
 
     spi_device_t spid = mocha_system_spi_device();
     spi_device_init(spid);
-    spi_device_enable_set(spid, true);
-    spi_device_flash_status_set(spid, 0);
+    spi_device_flash_mode_set(spid, spi_device_flash_mode_flash);
 
     while (true) {
         led_animation_run(ctx);
 
-        spi_device_cmd_t cmd = spi_device_cmd_get_non_blocking(spid);
-        if (cmd.status != spi_device_status_ready) {
-            if (cmd.status == spi_device_status_overflow) {
+        spi_device_software_command cmd;
+        enum spi_device_status status = spi_device_software_command_get_non_blocking(spid, &cmd);
+        if (status != spi_device_status_ready) {
+            if (status == spi_device_status_overflow) {
                 uprintf(ctx->console, "SPI payload overflow\n");
-                spi_device_flash_status_set(spid, 0);
+                spi_device_flash_status_busy_set(spid, false);
             }
             continue;
         }
 
         switch (cmd.opcode) {
-        case SPI_DEVICE_OPCODE_SECTOR_ERASE4B:
-        case SPI_DEVICE_OPCODE_SECTOR_ERASE:
+        case spi_device_opcode_sector_erase:
+        case spi_device_opcode_sector_erase_4b:
             // No need to erase SRAM.
             break;
-        case SPI_DEVICE_OPCODE_PAGE_PROGRAM4B:
-        case SPI_DEVICE_OPCODE_PAGE_PROGRAM:
+        case spi_device_opcode_page_program:
+        case spi_device_opcode_page_program_4b:
             if (cmd.payload_byte_count > 0) {
                 page_program(ctx->console, spid, cmd.address, cmd.payload_byte_count);
             }
             break;
-        case SPI_DEVICE_OPCODE_RESET:
+        case spi_device_opcode_reset:
             // Exit boot strap
             return true;
         default:
-            uprintf(ctx->console, "\nUnsupported command: 0x%0x", cmd.opcode);
+            uprintf(ctx->console, "Unsupported command: 0x%x\n", cmd.opcode);
             break;
         }
         // Finished processing the write, clear the busy bit.
-        spi_device_flash_status_set(spid, 0);
+        spi_device_flash_status_busy_set(spid, false);
     }
 
     return true;
@@ -159,23 +160,24 @@ static inline bool is_overriding_me(uintptr_t addr)
 void page_program(uart_t console, spi_device_t spid, uint32_t offset, uint32_t bytes)
 {
     uintptr_t ptr = offset;
-    uint32_t payload_offset = 0;
 
-    if (bytes > SPI_DEVICE_PAYLOAD_AREA_NUM_BYTES) {
-        uprintf(console, "\npage program size out of bounds");
+    if (bytes > spi_device_ingress_buffer_size_payload_fifo * sizeof(uint32_t)) {
+        uprintf(console, "page program size out of bounds\n");
         return;
     }
 
     // TODO: we need to check that the offset is valid within a memory address space.
     if (is_overriding_me(ptr) || is_overriding_me(ptr + bytes)) {
-        uprintf(console, "\nPlease don't override the bootrom's ram.");
+        uprintf(console, "Please don't override the bootrom's ram.\n");
         return;
     }
 
-    while (payload_offset < bytes) {
-        *((volatile uint64_t *)ptr) = spi_device_flash_payload_buffer_read64(spid, payload_offset);
-        ptr += sizeof(uint64_t);
-        payload_offset += sizeof(uint64_t);
+    uint32_t num_words = (bytes / 4);
+    if (bytes % 4 != 0) { num_words++; }
+    for (size_t i = 0; i < num_words; i++) {
+        uint32_t word =
+            VOLATILE_READ(spid->ingress_buffer[spi_device_ingress_buffer_offset_payload_fifo + i]);
+        ((uint32_t *)ptr)[i] = word;
     }
 }
 

sw/device/examples/spi.c

@@ -15,63 +15,67 @@ int main(void)
     spi_device_t spi_device = mocha_system_spi_device();
     uart_init(uart);
     spi_device_init(spi_device);
+    spi_device_flash_mode_set(spi_device, spi_device_flash_mode_flash);
+    const spi_device_flash_status clear_status = { 0 };
+    spi_device_flash_status_set(spi_device, clear_status);
 
     uprintf(uart, "Hello SPI in Mocha!\n");
 
     // Poll and process SPI command
-    spi_device_cmd_t cmd;
-    while (1) {
+    spi_device_software_command cmd;
+    while (true) {
         // Now process SPI command (if any)
-        cmd = spi_device_cmd_get(spi_device);
-        if (cmd.status != 0) {
-            uprintf(uart, "SPI payload overflow\n");
-            spi_device_flash_status_set(spi_device, 0);
-            continue;
+        enum spi_device_status status = spi_device_software_command_get(spi_device, &cmd);
+        if (status != spi_device_status_ready) {
+            if (status == spi_device_status_overflow) {
+                uprintf(uart, "SPI payload overflow\n");
+                spi_device_flash_status_set(spi_device, clear_status);
+                continue;
+            }
         }
 
         switch (cmd.opcode) {
-        case SPI_DEVICE_OPCODE_CHIP_ERASE:
+        case spi_device_opcode_chip_erase:
             uprintf(uart, "SPI CHIP ERASE");
             break;
-        case SPI_DEVICE_OPCODE_SECTOR_ERASE:
+        case spi_device_opcode_sector_erase:
             uprintf(uart, "SPI SECTOR ERASE");
             break;
-        case SPI_DEVICE_OPCODE_PAGE_PROGRAM:
+        case spi_device_opcode_page_program:
             uprintf(uart, "SPI PAGE PROGRAM");
             break;
-        case SPI_DEVICE_OPCODE_RESET:
+        case spi_device_opcode_reset:
             uprintf(uart, "SPI RESET");
             break;
         default:
             uprintf(uart, "SPI ??");
             break;
         }
 
-        if (cmd.address != UINT32_MAX) {
+        if (cmd.has_address) {
             uprintf(uart, " addr: 0x%x\n", cmd.address);
         }
 
         if (cmd.payload_byte_count > 0) {
             uprintf(uart, "payload bytes: 0x%x\n", cmd.payload_byte_count);
             uint32_t payload_word_count = ((uint32_t)cmd.payload_byte_count) / sizeof(uint32_t);
             if ((cmd.payload_byte_count % sizeof(uint32_t)) != 0) {
-                ++payload_word_count;
+                payload_word_count++;
             }
 
             uprintf(uart, "payload data:\n");
 
             uint32_t word;
             for (uint32_t i = 0; i < payload_word_count; ++i) {
-                word = spi_device_flash_payload_buffer_read(spi_device, i * sizeof(uint32_t));
-                spi_device_flash_read_buffer_write(spi_device, cmd.address + i * sizeof(uint32_t),
-                                                   word);
-                uprintf(uart, "0x%x\n", word);
+                if (spi_device_flash_payload_buffer_read_word(spi_device, i, &word)) {
+                    uprintf(uart, "0x%x\n", word);
+                }
             }
         }
 
         uprintf(uart, "\n");
 
-        spi_device_flash_status_set(spi_device, 0);
+        spi_device_flash_status_set(spi_device, clear_status);
     }
 
     return 0;

sw/device/lib/hal/mocha.c

@@ -120,7 +120,8 @@ i2c_t mocha_system_i2c(void)
 spi_device_t mocha_system_spi_device(void)
 {
 #if defined(__riscv_zcherihybrid)
-    return (spi_device_t)create_mmio_capability(spi_device_base, 0x1FC0u);
+    return (spi_device_t)create_mmio_capability(spi_device_base,
+                                                sizeof(struct spi_device_memory_layout));
 #else /* !defined(__riscv_zcherihybrid) */
     return (spi_device_t)spi_device_base;
 #endif /* defined(__riscv_zcherihybrid) */