hdr.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018 Kaspar Schleiser <kaspar@schleiser.de>
 *               2018 Inria
 *               2018 Freie Universität Berlin
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#pragma once
 
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define RIOTBOOT_MAGIC_V1       0x544f4952 /* "RIOT" */
 
#define RIOTBOOT_MAGIC_V2       0x54304952 /* "RI0T" */
 
#ifndef DOXYGEN
#if defined(MODULE_RIOTBOOT_HDR_V2)
#  define RIOTBOOT_MAGIC        RIOTBOOT_MAGIC_V2
#else
#  define RIOTBOOT_MAGIC        RIOTBOOT_MAGIC_V1
#endif
#endif
 
#define RIOTBOOT_HDR_IMAGE_BOOT_COUNT_SHIFT     0u
#define RIOTBOOT_HDR_IMAGE_BOOT_COUNT_MASK      (0x0000000f << RIOTBOOT_HDR_IMAGE_BOOT_COUNT_SHIFT)
#define RIOTBOOT_HDR_IMAGE_STATE_SHIFT          4u
#define RIOTBOOT_HDR_IMAGE_STATE_MASK           (0x0000000f << RIOTBOOT_HDR_IMAGE_STATE_SHIFT)
#ifndef CONFIG_RIOTBOOT_MAX_ATTEMPTS
#  define CONFIG_RIOTBOOT_MAX_ATTEMPTS          3u
#endif
 
static_assert(CONFIG_RIOTBOOT_MAX_ATTEMPTS > 0,
              "CONFIG_RIOTBOOT_MAX_ATTEMPTS must be at least 1");
 
static_assert(CONFIG_RIOTBOOT_MAX_ATTEMPTS <= 4,
              "CONFIG_RIOTBOOT_MAX_ATTEMPTS must be <= 4");
 
typedef enum riotboot_hdr_img_state {
    RIOTBOOT_HDR_IMG_STATE_INSTALLED   = 0x0f,      
    RIOTBOOT_HDR_IMG_STATE_DEACTIVATED = 0x0e,      
    RIOTBOOT_HDR_IMG_STATE_ACTIVATED   = 0x0c,      
    RIOTBOOT_HDR_IMG_STATE_CONFIRMED   = 0x08,      
    RIOTBOOT_HDR_IMG_STATE_DISMISSED   = 0x00,      
} riotboot_hdr_img_state_t;
 
struct riotboot_hdr_v1 {
    uint32_t magic_number;      
    uint32_t version;           
    uint32_t start_addr;        
    uint32_t chksum;            
};
 
struct riotboot_hdr_v2 {
    uint32_t magic_number;              
    uint32_t version;                   
    uint32_t start_addr;                
    uint32_t chksum;                    
    uint32_t flags;
};
 
typedef union riotboot_hdr {
    struct riotboot_hdr_v1 v1;  
    struct riotboot_hdr_v2 v2;  
} riotboot_hdr_t;
 
uint32_t riotboot_hdr_get_magic_number(const riotboot_hdr_t *riotboot_hdr);
 
uint32_t riotboot_hdr_get_version(const riotboot_hdr_t *riotboot_hdr);
 
uint32_t riotboot_hdr_get_start_addr(const riotboot_hdr_t *riotboot_hdr);
 
uint32_t riotboot_hdr_get_flags(const riotboot_hdr_t *riotboot_hdr);
 
uint32_t riotboot_hdr_get_checksum(const riotboot_hdr_t *riotboot_hdr);
 
void riotboot_hdr_print(const riotboot_hdr_t *riotboot_hdr);
 
int riotboot_hdr_validate(const riotboot_hdr_t *riotboot_hdr);
 
uint32_t riotboot_hdr_checksum(const riotboot_hdr_t *riotboot_hdr);
 
bool riotboot_hdr_is_v2(const riotboot_hdr_t *riotboot_hdr);
 
unsigned riotboot_hdr_get_boot_count(const riotboot_hdr_t *riotboot_hdr);
 
void riotboot_hdr_set_boot_count(riotboot_hdr_t *riotboot_hdr,
                                 unsigned boot_count);
 
int riotboot_hdr_set_img_state(riotboot_hdr_t *riotboot_hdr,
                               riotboot_hdr_img_state_t state);
 
int riotboot_hdr_get_img_state(const riotboot_hdr_t *riotboot_hdr);
 
#ifdef __cplusplus
}
#endif