flashwrite.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
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "riotboot/slot.h"
#include "periph/flashpage.h"
 
#ifndef CONFIG_RIOTBOOT_FLASHWRITE_RAW
#define CONFIG_RIOTBOOT_FLASHWRITE_RAW  1
#endif
 
#if CONFIG_RIOTBOOT_FLASHWRITE_RAW
 
#if (FLASHPAGE_WRITE_BLOCK_SIZE < 4)
#define RIOTBOOT_FLASHPAGE_BUFFER_SIZE 4
#else
#define RIOTBOOT_FLASHPAGE_BUFFER_SIZE FLASHPAGE_WRITE_BLOCK_SIZE
#endif
 
#else /* CONFIG_RIOTBOOT_FLASHWRITE_RAW */
 
#define RIOTBOOT_FLASHPAGE_BUFFER_SIZE FLASHPAGE_SIZE
 
#endif /* !CONFIG_RIOTBOOT_FLASHWRITE_RAW */
 
#define RIOTBOOT_FLASHPAGE_BUFFER_ATTRS \
    __attribute__((aligned(FLASHPAGE_WRITE_BLOCK_ALIGNMENT)))
 
typedef struct {
    int target_slot;                        
    size_t offset;                          
    unsigned flashpage;                     
    uint8_t RIOTBOOT_FLASHPAGE_BUFFER_ATTRS
        flashpage_buf[RIOTBOOT_FLASHPAGE_BUFFER_SIZE];
#if CONFIG_RIOTBOOT_FLASHWRITE_RAW || DOXYGEN
    uint8_t RIOTBOOT_FLASHPAGE_BUFFER_ATTRS
        firstblock_buf[RIOTBOOT_FLASHPAGE_BUFFER_SIZE];
#endif
} riotboot_flashwrite_t;
 
#define RIOTBOOT_FLASHWRITE_SKIPLEN     sizeof(RIOTBOOT_MAGIC)
 
int riotboot_flashwrite_init_raw(riotboot_flashwrite_t *state, int target_slot,
                                 size_t offset);
 
static inline int riotboot_flashwrite_init(riotboot_flashwrite_t *state,
                                           int target_slot)
{
    /* initialize state, but skip "RIOT" */
    return riotboot_flashwrite_init_raw(state, target_slot,
                                        RIOTBOOT_FLASHWRITE_SKIPLEN);
}
 
int riotboot_flashwrite_putbytes(riotboot_flashwrite_t *state,
                                 const uint8_t *bytes, size_t len, bool more);
int riotboot_flashwrite_flush(riotboot_flashwrite_t *state);
 
int riotboot_flashwrite_finish_raw(riotboot_flashwrite_t *state,
                                   const uint8_t *bytes, size_t len);
 
static inline int riotboot_flashwrite_finish(riotboot_flashwrite_t *state)
{
    return riotboot_flashwrite_finish_raw(state, (const uint8_t *)"RIOT",
                                          RIOTBOOT_FLASHWRITE_SKIPLEN);
}
 
int riotboot_flashwrite_invalidate(int slot);
 
int riotboot_flashwrite_invalidate_latest(void);
 
size_t riotboot_flashwrite_slotsize(const riotboot_flashwrite_t *state);
 
int riotboot_flashwrite_verify_sha256(const uint8_t *sha256_digest,
                                      size_t img_size, int target_slot);
 
#ifdef __cplusplus
}
#endif