ra8_dfu.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
 
#include "ra8_err.h"

typedef enum : uint32_t {
  k_ra8_dfu_mram_base     = 0x02000000U, 
  k_ra8_dfu_mram_size     = 0x00100000U, 
  k_ra8_dfu_bl_size       = 0x00020000U, 
  k_ra8_dfu_slot_a_base   = 0x02020000U, 
  k_ra8_dfu_slot_b_base   = 0x02090000U, 
  k_ra8_dfu_slot_size     = 0x00070000U, 
  k_ra8_dfu_page_size     = 0x00000020U, 
  k_ra8_dfu_hdr_size      = 0x00000020U, 
  k_ra8_dfu_img_max       = 0x0006FFE0U, 
  k_ra8_dfu_hdr_offset    = 0x0006FFE0U, 
  k_ra8_dfu_hdr_magic     = 0x52413844U, 
  k_ra8_dfu_trigger_magic = 0xDF00B007U, 
} ra8_dfu_layout_t;

typedef enum : uint32_t {
  k_ra8_dfu_run_base = 0x22020000U, 
} ra8_dfu_run_t;

typedef enum : uint8_t {
  k_ra8_dfu_slot_a    = 0U, 
  k_ra8_dfu_slot_b    = 1U, 
  k_ra8_dfu_slot_none = 2U, 
} ra8_dfu_slot_t;

typedef enum : uint8_t {
  k_ra8_dfu_action_dfu    = 0U, 
  k_ra8_dfu_action_jump_a = 1U, 
  k_ra8_dfu_action_jump_b = 2U, 
} ra8_dfu_action_t;

typedef struct {
  uint32_t magic;     
  uint32_t seq;       
  uint32_t img_len;   
  uint32_t img_crc32; 
  uint32_t entry;     
  uint32_t rsv0;      
  uint32_t rsv1;      
  uint32_t rsv2;      
} ra8_dfu_img_hdr_t;
 
static_assert(sizeof(ra8_dfu_img_hdr_t) == (uint32_t)k_ra8_dfu_hdr_size,
              "image header must be exactly one 32-byte MRAM page");

uint32_t ra8_dfu_crc32(const uint8_t* data, uint32_t len);

bool ra8_dfu_hdr_valid(const ra8_dfu_img_hdr_t* hdr, uint32_t computed_crc);

bool ra8_dfu_run_target_valid(uint32_t entry, uint32_t img_len);

void ra8_dfu_launch(uintptr_t src, uint32_t img_len, uint32_t entry);

ra8_dfu_slot_t ra8_dfu_select_slot(bool a_valid, uint32_t a_seq, bool b_valid, uint32_t b_seq);

ra8_dfu_action_t
ra8_dfu_boot_decide(bool dfu_trigger, bool a_valid, uint32_t a_seq, bool b_valid, uint32_t b_seq);
 
/* =============================================================================
 * MRAM slot access + program / verify (ra8_dfu_program.c)
 *
 * These touch the code-MRAM window. On the firmware target the program path
 * must execute from SRAM (the code-MRAM program loop must not run from MRAM --
 * see ra8_flash.h); each consumer's linker script places this TU + ra8_flash in
 * SRAM. The host test backs the MRAM window with fake memory, so the
 * full program -> read-back -> verify round-trip is unit-testable.
 * =============================================================================
 */

uintptr_t ra8_dfu_slot_base(ra8_dfu_slot_t slot);

ra8_dfu_slot_t ra8_dfu_other_slot(ra8_dfu_slot_t slot);

[[nodiscard]] ra8_err_t ra8_dfu_read_header(ra8_dfu_slot_t slot, ra8_dfu_img_hdr_t* out_hdr);

bool ra8_dfu_slot_valid(ra8_dfu_slot_t slot);

[[nodiscard]] ra8_err_t ra8_dfu_slot_seq(ra8_dfu_slot_t slot, uint32_t* out_seq);

[[nodiscard]] ra8_err_t ra8_dfu_program_prepare(ra8_dfu_slot_t inactive);

[[nodiscard]] ra8_err_t ra8_dfu_program_image(ra8_dfu_slot_t inactive,
                                              uint32_t       img_offset,
                                              const uint8_t* data,
                                              uint32_t       len);

[[nodiscard]] ra8_err_t
ra8_dfu_program_commit(ra8_dfu_slot_t inactive, uint32_t img_len, uint32_t seq);

[[nodiscard]] ra8_err_t ra8_dfu_program_verify(ra8_dfu_slot_t slot);
 
#ifdef __cplusplus
}
#endif