362 lines
12 KiB
C
Executable File
362 lines
12 KiB
C
Executable File
/*
|
|
* Copyright (C) 2017 XRADIO TECHNOLOGY CO., LTD. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the
|
|
* distribution.
|
|
* 3. Neither the name of XRADIO TECHNOLOGY CO., LTD. nor the names of
|
|
* its contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef _IMAGE_IMAGE_H_
|
|
#define _IMAGE_IMAGE_H_
|
|
|
|
#include <stdint.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/* compatibility for old bootloader (version < 0.3) due to OTA upgrade */
|
|
#define IMAGE_OPT_BL_COMPATIBILITY (0)
|
|
|
|
#define IMAGE_SEQ_NUM (2) /* max number of image sequence */
|
|
|
|
/**
|
|
* @brief Image sequence index, starting from 0
|
|
*/
|
|
typedef uint8_t image_seq_t;
|
|
|
|
/**
|
|
* @brief Image verification state definition
|
|
*/
|
|
typedef enum image_state {
|
|
IMAGE_STATE_UNVERIFIED = 0,
|
|
IMAGE_STATE_VERIFIED = 1,
|
|
IMAGE_STATE_UNDEFINED = 2,
|
|
} image_state_t;
|
|
|
|
/**
|
|
* @brief Image configuration definition
|
|
*/
|
|
typedef struct image_cfg {
|
|
image_seq_t seq;
|
|
image_state_t state;
|
|
} image_cfg_t;
|
|
|
|
/**
|
|
* @brief Image segment definition
|
|
*/
|
|
typedef enum image_segment {
|
|
IMAGE_SEG_HEADER = 0,
|
|
IMAGE_SEG_BODY = 1,
|
|
IMAGE_SEG_TAILER = 2,
|
|
} image_seg_t;
|
|
|
|
/**
|
|
* @brief Image validity definition
|
|
*/
|
|
typedef enum image_validity {
|
|
IMAGE_INVALID = 0,
|
|
IMAGE_VALID = 1,
|
|
} image_val_t;
|
|
|
|
typedef enum {
|
|
IMAGE_CHECK_NORMAL = 0,
|
|
IMAGE_CHECK_OTA = 1,
|
|
} image_check_type_t;
|
|
|
|
/**
|
|
* @brief Section header magic number definition (AWIH)
|
|
*/
|
|
#define IMAGE_MAGIC_NUMBER (0x48495741)
|
|
|
|
/**
|
|
* @brief Section ID definition
|
|
*/
|
|
#define IMAGE_BOOT_ID (0xA5FF5A00)
|
|
#define IMAGE_APP_ID (0xA5FE5A01)
|
|
#define IMAGE_APP_XIP_ID (0xA5FD5A02)
|
|
#define IMAGE_NET_ID (0xA5FC5A03)
|
|
#define IMAGE_NET_AP_ID (0xA5FB5A04)
|
|
#define IMAGE_WLAN_BL_ID (0xA5FA5A05)
|
|
#define IMAGE_WLAN_FW_ID (0xA5F95A06)
|
|
#define IMAGE_SYS_SDD_ID (0xA5F85A07)
|
|
#define IMAGE_APP_EXT_ID (0xA5F75A08) /* for XR32 only */
|
|
#define IMAGE_APP_PSRAM_ID (0xA5F65A09)
|
|
|
|
#if (defined(CONFIG_TRUSTZONE_BOOT) || defined(CONFIG_TRUSTZONE))
|
|
#define IMAGE_TZ_PARAM_ID (0xA5F55A0A)
|
|
#define IMAGE_TZ_APP_ID (0xA5F45A0B)
|
|
#define TZ_PARAMS_SIZE (0xC0)
|
|
#define IMAGE_TZ_XIP_ID (0xA5FD5A12)
|
|
#define IMAGE_TZ_PSRAM_ID (0xA5F65A19)
|
|
#endif
|
|
|
|
/* section ID defined by user starts from IMAGE_USER_ID */
|
|
#define IMAGE_USER_ID (0xB4FF4B00)
|
|
|
|
#define ECC_SIGN_SIZE (0x40)
|
|
#define TZ_PARAMS_TOTAL (TZ_PARAMS_SIZE + ECC_SIGN_SIZE)
|
|
#define ECC_PKEY_SIZE (0x40)
|
|
#define AES_KEY_SLOT_SIZE (0x00)
|
|
#define FCR_AES_ALIGN_SIZE (0x10)
|
|
|
|
/**
|
|
* @brief Section header definition (64 Bytes)
|
|
*/
|
|
typedef struct section_header {
|
|
uint32_t magic_number; /* magic number */
|
|
uint32_t version; /* version */
|
|
uint16_t header_chksum; /* header checksum */
|
|
uint16_t data_chksum; /* data checksum */
|
|
uint32_t data_size; /* data size */
|
|
uint32_t load_addr; /* load address */
|
|
uint32_t entry; /* entry point */
|
|
uint32_t body_len; /* body length */
|
|
uint32_t attribute; /* attribute */
|
|
uint32_t next_addr; /* next section address */
|
|
uint32_t id; /* section ID */
|
|
uint32_t priv[6]; /* private data */
|
|
} section_header_t;
|
|
|
|
#define IMAGE_HEADER_SIZE sizeof(section_header_t)
|
|
#define IMAGE_ATTR_FLAG_SIGN (1 << 2)
|
|
#define IMAGE_ATTR_FLAG_ENC (1 << 3)
|
|
#define IMAGE_ATTR_FLAG_COMPRESS (1 << 4)
|
|
#define IMAGE_ATTR_FLAG_SEC_BIN (1 << 5)
|
|
|
|
/**
|
|
* @brief OTA parameter definition
|
|
*/
|
|
typedef struct image_ota_param {
|
|
uint32_t ota_flash : 8; /* flash ID of OTA area */
|
|
uint32_t ota_size : 24; /* size of OTA area */
|
|
uint32_t ota_addr; /* start addr of OTA area */
|
|
uint16_t img_max_size; /* image max size (excluding bootloader, the unit is K) */
|
|
uint16_t img_xz_max_size; /* compressed image max size (the unit is K)*/
|
|
uint32_t bl_size; /* bootloader size */
|
|
image_seq_t running_seq; /* running image sequence */
|
|
uint8_t flash[IMAGE_SEQ_NUM]; /* flash ID which the image on */
|
|
uint32_t addr[IMAGE_SEQ_NUM]; /* image start addr, excluding bootloader */
|
|
} image_ota_param_t;
|
|
|
|
typedef struct {
|
|
uint32_t id;
|
|
uint32_t addr;
|
|
} sec_addr_t;
|
|
|
|
typedef struct {
|
|
image_ota_param_t iop;
|
|
uint8_t sec_num[IMAGE_SEQ_NUM];
|
|
sec_addr_t *sec_addr[IMAGE_SEQ_NUM];
|
|
} image_priv_t;
|
|
|
|
#define IMG_BL_FLASH(iop) ((iop)->flash[0]) /* bootloader flash */
|
|
#define IMG_BL_ADDR(iop) ((iop)->addr[0] - (iop)->bl_size) /* bootloader addr */
|
|
|
|
#define IMAGE_AREA_SIZE(size) ((size) * 1024)
|
|
|
|
#define IMAGE_INVALID_ADDR (0xFFFFFFFF)
|
|
#define IMAGE_INVALID_SIZE (0xFFFF)
|
|
|
|
/**
|
|
* @brief Initialize the image module
|
|
* @param[in] flash Flash device number of the 1st image region
|
|
* @param[in] addr Start address of the 1st image region (including bootloader)
|
|
* @retval 0 on success, -1 on failure
|
|
*/
|
|
int image_init(uint32_t flash, uint32_t addr);
|
|
|
|
/**
|
|
* @brief DeInitialize the image module
|
|
* @return None
|
|
*/
|
|
void image_deinit(void);
|
|
|
|
/**
|
|
* @brief Get OTA parameter
|
|
* @return Pointer to OTA parameter (read only)
|
|
*/
|
|
const image_ota_param_t *image_get_ota_param(void);
|
|
|
|
/**
|
|
* @brief Set running image sequence
|
|
* @param[in] seq Image sequence
|
|
* @return None
|
|
*/
|
|
void image_set_running_seq(image_seq_t seq);
|
|
|
|
/**
|
|
* @brief Get running image sequence
|
|
* @return running image sequence
|
|
*/
|
|
image_seq_t image_get_running_seq(void);
|
|
|
|
/**
|
|
* @brief Get address of the specified section in running image
|
|
* @param[in] id ID of the specified section
|
|
* @return section address
|
|
*/
|
|
uint32_t image_get_section_addr(uint32_t id);
|
|
|
|
/**
|
|
* @brief Read/Write an amount of image data from/to flash
|
|
* @param[in] id Section ID of the image data
|
|
* @param[in] seg Section segment of the image data
|
|
* @param[in] offset Offset into the segment from where to read/write data
|
|
* @param[in] buf Pointer to the data buffer
|
|
* @param[in] size Number of bytes to be read/written
|
|
* @param[in] do_write Read or write
|
|
* @return Number of bytes read/written
|
|
*/
|
|
uint32_t image_rw(uint32_t id, image_seg_t seg, uint32_t offset,
|
|
void *buf, uint32_t size, int do_write);
|
|
|
|
/*
|
|
* @brief For trustzone bootloader, first find out all the secure image information,
|
|
and look up non-secure information as needed. This is because all the
|
|
secure image must be used in bootloader.
|
|
*/
|
|
uint32_t tzboot_image_get_addr(image_priv_t *img, image_seq_t seq, uint32_t id);
|
|
|
|
uint32_t app_image_get_addr(image_priv_t *img, image_seq_t seq, uint32_t id);
|
|
|
|
uint32_t image_get_addr(image_priv_t *img, image_seq_t seq, uint32_t id);
|
|
|
|
uint32_t image_get_bl_size(section_header_t *sh);
|
|
|
|
/**
|
|
* @brief Read an amount of image data from flash
|
|
* @param[in] id Section ID of the image data
|
|
* @param[in] seg Section segment of the image data
|
|
* @param[in] offset Offset into the segment from where to read data
|
|
* @param[in] buf Pointer to the data buffer
|
|
* @param[in] size Number of bytes to be read
|
|
* @return Number of bytes read
|
|
*/
|
|
#ifdef CONFIG_SRAM_BIN_ENCRYPT
|
|
uint32_t image_read(uint32_t id, image_seg_t seg, uint32_t offset, void *buf, uint32_t size);
|
|
#else
|
|
static __inline uint32_t image_read(uint32_t id, image_seg_t seg,
|
|
uint32_t offset, void *buf, uint32_t size)
|
|
{
|
|
return image_rw(id, seg, offset, buf, size, 0);
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief Write an amount of image data to flash
|
|
* @param[in] id Section ID of the image data
|
|
* @param[in] seg Section segment of the image data
|
|
* @param[in] offset Offset into the segment from where to write data
|
|
* @param[in] buf Pointer to the data buffer
|
|
* @param[in] size Number of bytes to be written
|
|
* @return Number of bytes written
|
|
*/
|
|
static __inline uint32_t image_write(uint32_t id, image_seg_t seg,
|
|
uint32_t offset, void *buf, uint32_t size)
|
|
{
|
|
return image_rw(id, seg, offset, buf, size, 1);
|
|
}
|
|
|
|
uint16_t image_checksum16(uint8_t *data, uint32_t len);
|
|
|
|
/**
|
|
* @brief Get 16-bit checksum of the data buffer
|
|
* @param[in] buf Pointer to the data buffer
|
|
* @param[in] len length of the data buffer
|
|
* @return 16-bit checksum
|
|
*/
|
|
uint16_t image_get_checksum(void *buf, uint32_t len);
|
|
|
|
/**
|
|
* @brief Check vadility of the section header
|
|
* @param[in] sh Pointer to the section header
|
|
* @retval image_val_t, IMAGE_VALID on valid, IMAGE_INVALID on invalid
|
|
*/
|
|
image_val_t image_check_header(section_header_t *sh);
|
|
|
|
/**
|
|
* @brief Check vadility of the section data (body and tailer)
|
|
* @param[in] sh Pointer to the section header
|
|
* @param[in] body Pointer to the section body
|
|
* @param[in] body_len Length of the section body
|
|
* @param[in] tailer Pointer to the section tailer
|
|
* @param[in] tailer_len Length of the section tailer
|
|
* @retval image_val_t, IMAGE_VALID on valid, IMAGE_INVALID on invalid
|
|
*/
|
|
image_val_t image_check_data(section_header_t *sh, void *body, uint32_t body_len,
|
|
void *tailer, uint32_t tailer_len);
|
|
|
|
/**
|
|
* @brief Check vadility of the specified section in specified image
|
|
* @param[in] seq Sequence of the specified image
|
|
* @param[in] id Section ID of the specified section
|
|
* @retval image_val_t, IMAGE_VALID on valid, IMAGE_INVALID on invalid
|
|
*/
|
|
image_val_t image_check_section(image_seq_t seq, uint32_t id);
|
|
|
|
/**
|
|
* @brief Check vadility of all sections in the specified image
|
|
* @param[in] seq Sequence of the specified image
|
|
* @retval image_val_t, IMAGE_VALID on valid, IMAGE_INVALID on invalid
|
|
*/
|
|
image_val_t image_check_sections(image_seq_t seq);
|
|
|
|
/**
|
|
* @brief Check vadility of all sections in the ota image
|
|
* @param[in] seq Sequence of the specified image
|
|
* @retval image_val_t, IMAGE_VALID on valid, IMAGE_INVALID on invalid
|
|
*/
|
|
image_val_t image_check_ota_sections(image_seq_t seq);
|
|
|
|
/**
|
|
* @brief Get the size of the running image (including bootloader)
|
|
* @return the size of the running image, 0 on bad image
|
|
*/
|
|
uint32_t image_get_size(void);
|
|
|
|
/**
|
|
* @brief Get the image configuration
|
|
* @param[in] cfg Pointer to image configuration
|
|
* @return 0 on success, -1 on failure
|
|
*/
|
|
int image_get_cfg(image_cfg_t *cfg);
|
|
|
|
/**
|
|
* @brief Set the image configuration
|
|
* @param[in] cfg Pointer to image configuration
|
|
* @return 0 on success, -1 on failure
|
|
*/
|
|
int image_set_cfg(image_cfg_t *cfg);
|
|
|
|
#ifdef CONFIG_ROM
|
|
void image_set_dbg_mask(uint16_t dbg_mask);
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* _IMAGE_IMAGE_H_ */
|