All the states

include/bus_spi.h

@@ -5,6 +5,7 @@
 #include <stdint.h>
 
 #include "pins.h"
+#include "state_store.h"
 
 typedef struct bus_spi_t bus_spi_t;
 
@@ -28,7 +29,7 @@ typedef struct
     spi_cs_changed_f cs_changed;
 } spi_slave_t;
 
-bus_spi_t *bus_spi_new(pins_t *pins, uint8_t *ram, size_t ram_size);
+bus_spi_t *bus_spi_new(pins_t *pins, uint8_t *ram, size_t ram_size, state_store_t *store);
 void bus_spi_reset(bus_spi_t *);
 void bus_spi_free(bus_spi_t *);
 void bus_spi_step(bus_spi_t *);

include/components/i2c/bma425.h

@@ -1,5 +1,6 @@
 #pragma once
 
 #include "bus_i2c.h"
+#include "state_store.h"
 
-i2c_slave_t bma425_new();
+i2c_slave_t bma425_new(state_store_t *store);

include/components/i2c/cst816s.h

@@ -2,6 +2,7 @@
 
 #include "bus_i2c.h"
 #include "pins.h"
+#include "state_store.h"
 
 typedef enum
 {
@@ -17,7 +18,7 @@ typedef enum
 
 typedef struct cst816s_t cst816s_t;
 
-cst816s_t *cst816s_new(pins_t *pins, int irqPin);
+cst816s_t *cst816s_new(pins_t *pins, state_store_t *store, int irqPin);
 i2c_slave_t cst816s_get_slave(cst816s_t *);
 
 void cst816s_do_touch(cst816s_t *, touch_gesture_t gesture, uint16_t x, uint16_t y);

include/components/i2c/hrs3300.h

@@ -1,10 +1,11 @@
 #pragma once
 
 #include "bus_i2c.h"
+#include "state_store.h"
 
 typedef struct hrs3300_t hrs3300_t;
 
-hrs3300_t *hrs3300_new();
+hrs3300_t *hrs3300_new(state_store_t *store);
 i2c_slave_t hrs3300_get_slave(hrs3300_t *);
 
 void hrs3300_set_ch0(hrs3300_t *, uint32_t value);

include/components/spi/spinorflash.h

@@ -1,12 +1,13 @@
 #pragma once
 
 #include "bus_spi.h"
+#include "state_store.h"
 
 #include <stddef.h>
 
 typedef struct spinorflash_t spinorflash_t;
 
-spinorflash_t *spinorflash_new(size_t size, size_t sector_size);
+spinorflash_t *spinorflash_new(state_store_t *store, size_t size, size_t sector_size);
 spi_slave_t spinorflash_get_slave(spinorflash_t *);
 
 size_t spinorflash_get_write_count(spinorflash_t *);

include/components/spi/st7789.h

@@ -8,7 +8,7 @@ typedef struct st7789_t st7789_t;
 #define DISPLAY_BUFFER_HEIGHT 320
 #define BYTES_PER_PIXEL 2 // We assume 16bpp format
 
-st7789_t* st7789_new();
+st7789_t* st7789_new(state_store_t *store);
 spi_slave_t st7789_get_slave(st7789_t *);
 
 void st7789_read_screen(st7789_t *, uint8_t *data, size_t width, size_t height);

include/config.h

@@ -35,7 +35,7 @@
 #endif
 
 #ifndef ENABLE_MEASUREMENT
-#define ENABLE_MEASUREMENT 0
+#define ENABLE_MEASUREMENT 1
 #endif
 
 #ifndef ABORT_ON_INVALID_MEM_ACCESS

include/cpu.h

@@ -7,13 +7,14 @@
 #include "arm.h"
 #include "memory.h"
 #include "runlog.h"
+#include "state_store.h"
 
 typedef struct cpu_inst_t cpu_t;
 
 typedef void (*branch_cb_t)(cpu_t *, uint32_t old_pc, uint32_t new_pc, void *userdata);
 typedef void (*mem_watchpoint_cb_t)(cpu_t *, bool isWrite, uint32_t addr, size_t size, uint32_t value_old, uint32_t value_new, void *userdata);
 
-cpu_t *cpu_new(const uint8_t *program, size_t program_size, memory_map_t *mem, size_t max_external_interrupts, size_t priority_bits);
+cpu_t *cpu_new(const uint8_t *program, size_t program_size, memory_map_t *mem, state_store_t *store, size_t max_external_interrupts, size_t priority_bits);
 void cpu_free(cpu_t *);
 void cpu_reset(cpu_t *);
 // Returns the number of cycles that the CPU ran for

include/nrf52832.h

@@ -4,6 +4,7 @@
 #include "bus_i2c.h"
 #include "bus_spi.h"
 #include "program.h"
+#include "state_store.h"
 #include "peripherals/nrf52832/rtc.h"
 
 #define NRF52832_SRAM_SIZE 0x10000
@@ -84,7 +85,7 @@ enum
 
 typedef struct NRF52832_inst_t NRF52832_t;
 
-NRF52832_t *nrf52832_new(const program_t *flash, size_t sram_size);
+NRF52832_t *nrf52832_new(const program_t *flash, size_t sram_size, state_store_t *store);
 void nrf52832_reset(NRF52832_t *);
 int nrf52832_step(NRF52832_t *);
 
@@ -99,3 +100,5 @@ size_t nrf52832_get_sram_size(NRF52832_t *);
 uint64_t nrf52832_get_cycle_counter(NRF52832_t *);
 
 bool nrf52832_flash_write(NRF52832_t *, uint32_t addr, uint8_t value);
+
+void nrf52832_reload_state(NRF52832_t *);

include/peripherals/dcb.h

@@ -2,4 +2,4 @@
 
 #include "peripherals/peripheral.h"
 
-PERIPHERAL(DCB, dcb)
+PERIPHERAL(DCB, dcb, state_store_t *store)

include/peripherals/dwt.h

@@ -4,6 +4,6 @@
 
 #define DWT_CYCCNTENA 0
 
-PERIPHERAL(DWT, dwt)
+PERIPHERAL(DWT, dwt, state_store_t *store)
 
 void dwt_increment_cycle(DWT_t *dwt, unsigned int count);

include/peripherals/nvic.h

@@ -4,4 +4,4 @@
 
 #include "cpu.h"
 
-PERIPHERAL(NVIC, nvic, cpu_t *cpu, size_t priority_bits)
+PERIPHERAL(NVIC, nvic, cpu_t *cpu, state_store_t *store, size_t priority_bits)

include/peripherals/scb.h

@@ -27,7 +27,7 @@ typedef union
 
 static_assert(sizeof(SCB_CCR_t) == 4, "SCB_CCR_t size is incorrect");
 
-PERIPHERAL(SCB, scb, cpu_t *cpu)
+PERIPHERAL(SCB, scb, cpu_t *cpu, state_store_t *store)
 
 uint32_t scb_get_prigroup(SCB_t *);
 SCB_CCR_t scb_get_ccr(SCB_t *);

include/peripherals/scb_fp.h

@@ -2,7 +2,7 @@
 
 #include "arm.h"
 
-PERIPHERAL(SCB_FP, scb_fp)
+PERIPHERAL(SCB_FP, scb_fp, state_store_t *store)
 
 FPCCR_t scb_fp_get_fpccr(SCB_FP_t *scb_fp);
 uint32_t scb_fp_get_fpscr(SCB_FP_t *scb_fp);

include/pinetime.h

@@ -31,3 +31,6 @@ st7789_t *pinetime_get_st7789(pinetime_t *);
 cst816s_t *pinetime_get_cst816s(pinetime_t *);
 hrs3300_t *pinetime_get_hrs3300(pinetime_t *);
 spinorflash_t *pinetime_get_spinorflash(pinetime_t *pt);
+
+uint8_t *pinetime_save_state(pinetime_t *pt, size_t *size);
+bool pinetime_load_state(pinetime_t *pt, uint8_t *data, size_t size);

include/pins.h

@@ -2,6 +2,8 @@
 
 #define PINS_COUNT 32
 
+#include "state_store.h"
+
 #include <stdbool.h>
 #include <stdint.h>
 
@@ -34,7 +36,7 @@ typedef enum
 #define pins_set_input(pins, pin) pins_set_dir(pins, pin, pins_get_dir(pins, pin) & ~PIN_OUTPUT)
 #define pins_set_output(pins, pin) pins_set_dir(pins, pin, pins_get_dir(pins, pin) | PIN_OUTPUT)
 
-pins_t *pins_new(void);
+pins_t *pins_new(state_store_t *store);
 void pins_free(pins_t *);
 
 void pins_reset(pins_t *);

include/state_store.h

@@ -11,11 +11,26 @@ typedef uint16_t state_key_t;
 
 enum
 {
-    STATE_KEY_POWER = 1,
+    STATE_KEY_CPU = 1,
+    STATE_KEY_MEMORY,
+    STATE_KEY_PINS,
+    STATE_KEY_BUS_SPI,
+    STATE_KEY_DCB,
+    STATE_KEY_DWT,
+    STATE_KEY_NVIC,
+    STATE_KEY_SCB_FP,
+    STATE_KEY_SCB,
+    STATE_KEY_BMA425,
+    STATE_KEY_CST816S,
+    STATE_KEY_HRS3300,
+    STATE_KEY_SPINORFLASH,
+    STATE_KEY_ST7789,
+
+    STATE_KEY_POWER = 0x0100,
     STATE_KEY_CLOCK,
 
-    STATE_KEY_SPIM0 = 0x0100,
-    STATE_KEY_TWIM0 = 0x0200,
+    STATE_KEY_SPIM0 = 0x0200,
+    STATE_KEY_TWIM0 = 0x0300,
 };
 
 state_store_t *state_store_new();
@@ -25,4 +40,4 @@ void state_store_register(state_store_t *store, state_key_t key, void *data, siz
 void state_store_freeze(state_store_t *);
 
 uint8_t *state_store_save(state_store_t *, size_t *size);
-bool state_store_load(state_store_t *, uint8_t *data, size_t size);
+bool state_store_load(state_store_t *, const uint8_t *data, size_t size);

include/util.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+static inline uint8_t *read_file_u8(const char *path, size_t *size)
+{
+    FILE *f = fopen(path, "rb");
+    if (f == NULL)
+    {
+        fprintf(stderr, "Failed to open %s\n", path);
+        return NULL;
+    }
+
+    fseek(f, 0, SEEK_END);
+    long fsize = ftell(f);
+    fseek(f, 0, SEEK_SET);
+
+    uint8_t *data = malloc(fsize);
+    if (fread(data, 1, fsize, f) != (size_t)fsize)
+    {
+        fprintf(stderr, "Failed to read %s\n", path);
+        return NULL;
+    }
+    fclose(f);
+
+    *size = fsize;
+    return data;
+}

src/bus_spi.c

@@ -15,23 +15,30 @@
 
 struct bus_spi_t
 {
+    struct state
+    {
+        bool was_selected[MAX_SLAVES];
+    };
+
     uint8_t *ram;
     size_t ram_size;
 
-    bool was_selected[MAX_SLAVES];
     spi_slave_t *slaves[MAX_SLAVES];
     uint8_t slave_pin[MAX_SLAVES];
     size_t slave_count;
 
     pins_t *pins;
 };
 
-bus_spi_t *bus_spi_new(pins_t *pins, uint8_t *ram, size_t ram_size)
+bus_spi_t *bus_spi_new(pins_t *pins, uint8_t *ram, size_t ram_size, state_store_t *store)
 {
-    bus_spi_t *spi = (bus_spi_t *)calloc(1, sizeof(bus_spi_t));
+    bus_spi_t *spi = calloc(1, sizeof(bus_spi_t));
     spi->pins = pins;
     spi->ram = ram;
     spi->ram_size = ram_size;
+
+    state_store_register(store, STATE_KEY_BUS_SPI, spi, sizeof(struct state));
+
     return spi;
 }
 

src/component/i2c/bma425.c

@@ -238,10 +238,12 @@ size_t bma425_read(uint8_t *data, size_t data_size, void *userdata)
     return data_size;
 }
 
-i2c_slave_t bma425_new()
+i2c_slave_t bma425_new(state_store_t *store)
 {
     bma425_t *bma425 = malloc(sizeof(bma425_t));
 
+    state_store_register(store, STATE_KEY_BMA425, bma425, sizeof(bma425_t));
+
     return (i2c_slave_t){
         .userdata = bma425,
         .write = bma425_write,

src/component/i2c/cst816s.c

@@ -25,14 +25,17 @@ typedef struct __attribute__((packed))
 
 struct cst816s_t
 {
-    pins_t *pins;
-    int irqPin;
+    struct state
+    {
+        uint8_t next_read[MAX_READ_SIZE];
+        size_t next_read_size;
 
-    uint8_t next_read[MAX_READ_SIZE];
-    size_t next_read_size;
+        touchdata_t touchdata;
+        bool has_touch;
+    };
 
-    touchdata_t touchdata;
-    bool has_touch;
+    pins_t *pins;
+    int irqPin;
 };
 
 void cst816s_reset(void *userdata)
@@ -114,12 +117,14 @@ size_t cst816s_read(uint8_t *data, size_t data_size, void *userdata)
     return data_size;
 }
 
-cst816s_t *cst816s_new(pins_t *pins, int irqPin)
+cst816s_t *cst816s_new(pins_t *pins, state_store_t *store, int irqPin)
 {
     cst816s_t *cst816s = calloc(1, sizeof(cst816s_t));
     cst816s->pins = pins;
     cst816s->irqPin = irqPin;
 
+    state_store_register(store, STATE_KEY_CST816S, cst816s, sizeof(struct state));
+
     return cst816s;
 }
 

src/component/i2c/hrs3300.c

@@ -102,9 +102,13 @@ size_t hrs3300_read(uint8_t *data, size_t data_size, void *userdata)
     return data_size;
 }
 
-hrs3300_t *hrs3300_new()
+hrs3300_t *hrs3300_new(state_store_t *store)
 {
-    return calloc(1, sizeof(hrs3300_t));
+    hrs3300_t *hrs = calloc(1, sizeof(hrs3300_t));
+
+    state_store_register(store, STATE_KEY_HRS3300, hrs, sizeof(hrs3300_t));
+
+    return hrs;
 }
 
 i2c_slave_t hrs3300_get_slave(hrs3300_t *hrs3300)