ra8_ota.h

Go to the documentation of this file.

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

typedef enum : uint32_t {
  k_ra8_ota_chunk_bytes         = 4096U,    
  k_ra8_ota_manifest_max_bytes  = 2048U,    
  k_ra8_ota_sha256_bytes        = 32U,      
  k_ra8_ota_signature_max_bytes = 96U,      
  k_ra8_ota_url_max_bytes       = 256U,     
  k_ra8_ota_version_str_bytes   = 32U,      
  k_ra8_ota_max_image_bytes     = 0x80000U, 
  k_ra8_ota_thread_stack_bytes  = 4096U,    
} ra8_ota_constants_t;

typedef enum : uint8_t {
  k_ra8_ota_state_idle        = 0U, 
  k_ra8_ota_state_checking    = 1U, 
  k_ra8_ota_state_downloading = 2U, 
  k_ra8_ota_state_verifying   = 3U, 
  k_ra8_ota_state_committing  = 4U, 
  k_ra8_ota_state_done        = 5U, 
  k_ra8_ota_state_error       = 6U, 
  k_ra8_ota_state_count       = 7U, 
} ra8_ota_state_t;

typedef struct {
  char     version[k_ra8_ota_version_str_bytes];     
  char     image_url[k_ra8_ota_url_max_bytes];       
  uint32_t image_size_bytes;                         
  uint8_t  image_sha256[k_ra8_ota_sha256_bytes];     
  uint8_t  signature[k_ra8_ota_signature_max_bytes]; 
  uint16_t signature_len;                            
} ra8_ota_manifest_t;

typedef struct {
  ra8_ota_state_t state;       
  uint32_t        bytes_done;  
  uint32_t        bytes_total; 
  ra8_err_t       last_err;    
} ra8_ota_progress_t;

typedef void (*ra8_ota_progress_cb_t)(const ra8_ota_progress_t* p);

typedef struct {
  ra8_err_t (*open)(void* ctx, const char* url, uint32_t* out_content_len);

  ra8_err_t (*read)(void* ctx, uint8_t* dst, uint32_t cap, uint32_t* out_len);

  ra8_err_t (*close)(void* ctx);

  void* ctx;
} ra8_ota_net_iface_t;

typedef struct {
  ra8_err_t (*sha256_init)(void* ctx);
  ra8_err_t (*sha256_update)(void* ctx, const uint8_t* data, uint32_t len);
  ra8_err_t (*sha256_final)(void* ctx, uint8_t out[k_ra8_ota_sha256_bytes]);

  ra8_err_t (*ecdsa_verify)(void*          ctx,
                            uint32_t       pubkey_handle,
                            const uint8_t  digest[k_ra8_ota_sha256_bytes],
                            const uint8_t* sig,
                            uint32_t       sig_len);

  void* ctx;
} ra8_ota_crypto_iface_t;

typedef struct {
  ra8_err_t (*erase)(void* ctx, uint32_t addr, uint32_t len);
  ra8_err_t (*program)(void* ctx, uint32_t addr, const uint8_t* src, uint32_t len);
  ra8_err_t (*set_startup)(void* ctx, uint8_t which_bank, bool persistent);
  ra8_err_t (*readback)(void* ctx, uint32_t addr, uint8_t* dst, uint32_t len);

  uint32_t inactive_bank_addr;
  uint32_t bank_size_bytes;
  uint8_t inactive_bank_index;

  void* ctx;
} ra8_ota_flash_iface_t;

typedef struct {
  char manifest_url[k_ra8_ota_url_max_bytes];

  uint32_t pubkey_handle;

  ra8_ota_progress_cb_t on_progress;

  ra8_ota_net_iface_t net;

  ra8_ota_crypto_iface_t crypto;

  ra8_ota_flash_iface_t flash;

  bool run_as_thread;
} ra8_ota_cfg_t;

[[nodiscard]] ra8_err_t ra8_ota_init(const ra8_ota_cfg_t* cfg);

[[nodiscard]] ra8_err_t ra8_ota_deinit(void);

[[nodiscard]] ra8_err_t ra8_ota_check_for_update(ra8_ota_manifest_t* out_manifest);

[[nodiscard]] ra8_err_t ra8_ota_download_to_inactive_bank(const ra8_ota_manifest_t* manifest);

[[nodiscard]] ra8_err_t ra8_ota_verify_signature(const ra8_ota_manifest_t* manifest);

[[nodiscard]] ra8_err_t ra8_ota_commit_and_reboot(void);

ra8_ota_state_t ra8_ota_get_state(void);

[[nodiscard]] ra8_err_t ra8_ota_run_step(void);

[[nodiscard]] ra8_err_t ra8_ota_run_full_update(void);

void ra8_ota_system_reset_hook(void);
 
#ifdef __cplusplus
}
#endif