RTOS/SDK_GD32W51x
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
179cffc2c1f89b72680d73d62556828745526c8f
SDK_GD32W51x/MBL/source/mbl_status.c
gaoyang3513 179cffc2c1 [Add] First commit
2023-05-18 18:53:00 +08:00

758 lines
23 KiB
C
Raw Blame History

/*!
\file mbl_status.c
\brief MBL status operation for GD32W51x WiFi SDK
\version 2021-10-30, V1.0.0, firmware for GD32W51x
*/
/*
Copyright (c) 2021, GigaDevice Semiconductor Inc.
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 the copyright holder 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 HOLDER 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.
*/
#include "mbl_includes.h"
/*!
\brief print data
\param[in] data: pointer to data
\param[in] count: print count
\param[out] none
\retval result of print data
*/
static int print_data(uint8_t *data, uint32_t count)
{
uint32_t i;
for (i = 0; i < count; i++) {
if (i % 16 == 0)
rom_printf("\r\n\t");
rom_printf("%02x ", *(data + i));
}
rom_printf("\r\n");
return 0;
}
/*!
\brief print sw information
\param[in] sw_info: pointer to sw information
\param[out] none
\retval result of print sw information
*/
static void sw_info_print(struct sw_info_t *sw_info)
{
rom_printf("Add sw info:\r\n");
rom_printf(" Type: %d\r\n", sw_info->type);
rom_printf(" Version: 0x%x\r\n", sw_info->version);
#ifdef BOOT_RECORD
rom_printf(" Boot Record: ");
print_data(sw_info->record, sw_info->record_len);
#else
rom_printf(" Digest: ");
print_data(sw_info->digest, IMG_HASH_LEN);
rom_printf(" Signer ID: ");
print_data(sw_info->signer_id, IMG_PK_LEN);
#endif
}
/*!
\brief mbl status initialize
\param[in] none
\param[out] none
\retval none
*/
void mbl_status_init(void)
{
struct tfm_boot_data *boot_data;
boot_data = (struct tfm_boot_data *)MBL_SHARED_DATA_START;
memset((void *)MBL_SHARED_DATA_START, 0, MBL_SHARED_DATA_SIZE);
boot_data->header.tlv_magic = SHARED_DATA_TLV_INFO_MAGIC;
boot_data->header.tlv_tot_len = SHARED_DATA_HEADER_SIZE;
}
/* See in boot_record.h */
/*!
\brief mbl add status type, length and value
\param[in] major_type: major type, identify consumer
\param[in] minor_type: minor type, identify tlv type
\param[in] size: size of data
\param[in] data: pointer to data
\param[out] none
\retval result of mbl status add tlv
\arg SHARED_MEMORY_OK: mbl status add tlv success
\arg SHARED_MEMORY_OVERWRITE: shared memory overwrite
\arg SHARED_MEMORY_OVERFLOW: shared memory overflow
*/
enum shared_memory_err_t
mbl_status_tlv_add(uint8_t major_type,
uint16_t minor_type,
size_t size,
const uint8_t *data)
{
struct shared_data_tlv_entry tlv_entry = {0};
struct tfm_boot_data *boot_data;
uint8_t *next_tlv;
uint32_t tlv_end, offset;
boot_data = (struct tfm_boot_data *)MBL_SHARED_DATA_START;
/* Check whether TLV entry is already added.
* Get the boundaries of TLV section
*/
tlv_end = MBL_SHARED_DATA_START + boot_data->header.tlv_tot_len;
offset = MBL_SHARED_DATA_START + SHARED_DATA_HEADER_SIZE;
/* Iterates over the TLV section looks for the same entry if found then
* returns with error: SHARED_MEMORY_OVERWRITE
*/
for (; offset < tlv_end; offset += tlv_entry.tlv_len) {
/* Create local copy to avoid unaligned access */
memcpy(&tlv_entry, (const void *)offset, SHARED_DATA_ENTRY_HEADER_SIZE);
if (GET_MAJOR(tlv_entry.tlv_type) == major_type &&
GET_MINOR(tlv_entry.tlv_type) == minor_type) {
return SHARED_MEMORY_OVERWRITE;
}
}
/* Add TLV entry */
tlv_entry.tlv_type = SET_TLV_TYPE(major_type, minor_type);
tlv_entry.tlv_len = SHARED_DATA_ENTRY_SIZE(size);
/* Verify overflow of shared area */
if ((boot_data->header.tlv_tot_len + tlv_entry.tlv_len) > IBL_SHARED_DATA_SIZE){
return SHARED_MEMORY_OVERFLOW;
}
next_tlv = (uint8_t *)boot_data + boot_data->header.tlv_tot_len;
memcpy(next_tlv, &tlv_entry, SHARED_DATA_ENTRY_HEADER_SIZE);
next_tlv += SHARED_DATA_ENTRY_HEADER_SIZE;
memcpy(next_tlv, data, size);
boot_data->header.tlv_tot_len += tlv_entry.tlv_len;
return SHARED_MEMORY_OK;
}
/*!
\brief mbl get status type, length and value
\param[in] major_type: major type, identify consumer
\param[in] minor_type: minor type, identify tlv type
\param[out] tlv_len: pointer to tlv length
\param[out] tlv_ptr: pointer to tlv address
\retval result of mbl get status tlv
*/
int32_t mbl_status_tlv_get(uint8_t major_type,
uint16_t minor_type,
uint16_t *tlv_len,
uint8_t **tlv_ptr)
{
struct shared_data_tlv_entry tlv_entry;
struct tfm_boot_data *boot_data;
uint8_t *tlv_end;
uint8_t *tlv_curr;
boot_data = (struct tfm_boot_data *)MBL_SHARED_DATA_START;
if (boot_data->header.tlv_magic != SHARED_DATA_TLV_INFO_MAGIC) {
return -1;
}
/* Get the boundaries of TLV section where to lookup*/
tlv_end = (uint8_t *)&boot_data + boot_data->header.tlv_tot_len;
if (*tlv_ptr == NULL) {
/* At first call set to the beginning of the TLV section */
tlv_curr = boot_data->data;
} else {
/* Any subsequent call set to the next TLV entry */
memcpy(&tlv_entry, *tlv_ptr, SHARED_DATA_ENTRY_HEADER_SIZE);
tlv_curr = (*tlv_ptr) + tlv_entry.tlv_len;
}
/* Iterates over the TLV section and returns the address and size of TLVs
* with requested module identifier
*/
for (; tlv_curr < tlv_end; tlv_curr += tlv_entry.tlv_len) {
/* Create local copy to avoid unaligned access */
memcpy(&tlv_entry, tlv_curr, SHARED_DATA_ENTRY_HEADER_SIZE);
if (GET_MAJOR(tlv_entry.tlv_type) == major_type &&
GET_MINOR(tlv_entry.tlv_type) == minor_type) {
*tlv_ptr = tlv_curr + SHARED_DATA_ENTRY_HEADER_SIZE;
if (tlv_len)
*tlv_len = tlv_entry.tlv_len - SHARED_DATA_ENTRY_HEADER_SIZE;
return 1;
}
}
return 0;
}
#ifndef BOOT_RECORD
/*!
\brief Add a type identifier(short test name) of SW component to the shared
memory area
\param[in] sw_module: identifier of the SW component
\param[out] none
\retval result of add sw type
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
static enum boot_status_err_t
mbl_status_sw_type_add(uint32_t sw_module)
{
/*FixMe: Use a hard coded value for now. Later on when multiple image will
* be handled by MCUBoot then this must be revisited.
*/
uint16_t ias_minor;
uint32_t cnt;
enum shared_memory_err_t res;
char *sw_type;
switch (sw_module) {
case SW_MBL:
sw_type = "MBL";
cnt = 3;
break;
case SW_PROT:
sw_type = "PROT";
cnt = 4;
break;
case SW_AROT:
sw_type = "AROT";
cnt = 4;
break;
case SW_NSPE:
sw_type = "NSPE";
cnt = 4;
break;
default:
sw_type = "UNKNOWN";
cnt = 7;
}
/* Add the type identifier of the SW component to the shared data area */
ias_minor = SET_IAS_MINOR(sw_module, SW_TYPE);
res = mbl_status_tlv_add(TLV_MAJOR_IAS,
ias_minor,
cnt,
(const uint8_t *)sw_type);
if (res) {
return BOOT_STATUS_ERROR;
}
return BOOT_STATUS_OK;
}
/*!
\brief add status sw version
\param[in] sw_module: identifier of the sw component
\param[in] version: sw version
\param[out] none
\retval result of add sw version
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
static enum boot_status_err_t
mbl_status_sw_version_add(uint32_t sw_module, uint32_t version)
{
int32_t cnt;
enum shared_memory_err_t res;
char sw_version[14]; /* 8bit.8bit.16bit: 3 + 1 + 3 + 1 + 5 + 1 */
uint16_t ias_minor;
/* FixMe: snprintf can be replaced with a custom implementation */
cnt = snprintf(sw_version, sizeof(sw_version), "%u.%u.%u",
(version >> 24),
((version & 0xFF0000) >> 16),
(version & 0xFFFF));
if (cnt < 0 || cnt >= sizeof(sw_version)) {
return BOOT_STATUS_ERROR;
}
/* Add the version of the SW component to the shared data area */
ias_minor = SET_IAS_MINOR(sw_module, SW_VERSION);
res = mbl_status_tlv_add(TLV_MAJOR_IAS,
ias_minor,
cnt,
(const uint8_t *)sw_version);
if (res) {
return BOOT_STATUS_ERROR;
}
return BOOT_STATUS_OK;
}
/*!
\brief add status sw digest
\param[in] sw_module: identifier of the sw component
\param[in] digest: pointer to diget add to tlv
\param[out] none
\retval result of add sw digest
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
static enum boot_status_err_t
mbl_status_sw_digest_add(uint32_t sw_module, uint8_t *digest)
{
uint16_t ias_minor;
enum shared_memory_err_t res;
char measure_type[] = "SHA256";
/* Add the image's hash value to the shared data area */
ias_minor = SET_IAS_MINOR(sw_module, SW_MEASURE_VALUE);
res = mbl_status_tlv_add(TLV_MAJOR_IAS,
ias_minor,
IMG_HASH_LEN,
digest);
if (res) {
return BOOT_STATUS_ERROR;
}
/* Add the measurement type to the shared data area */
ias_minor = SET_IAS_MINOR(sw_module, SW_MEASURE_TYPE);
res = mbl_status_tlv_add(TLV_MAJOR_IAS,
ias_minor,
sizeof(measure_type) - 1,
(const uint8_t *)measure_type);
if (res) {
return BOOT_STATUS_ERROR;
}
return BOOT_STATUS_OK;
}
/*!
\brief add status sw signer
\param[in] sw_module: identifier of the sw component
\param[in] signer_id: pointer to signer id
\param[out] none
\retval result of add sw signer
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
static enum boot_status_err_t
mbl_status_sw_signer_add(uint32_t sw_module, uint8_t *signer_id)
{
uint16_t ias_minor;
enum shared_memory_err_t res;
/* Add the hash of the public key to the shared data area */
ias_minor = SET_IAS_MINOR(sw_module, SW_SIGNER_ID);
res = mbl_status_tlv_add(TLV_MAJOR_IAS,
ias_minor,
IMG_PKHASH_LEN,
signer_id);
if (res) {
return BOOT_STATUS_ERROR;
}
return BOOT_STATUS_OK;
}
#endif
/*!
\brief add status sw information
\param[in] sw_info: pointer to sw information
\param[out] none
\retval result of add sw information
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
enum boot_status_err_t
mbl_status_sw_info_add(struct sw_info_t *sw_info)
{
uint32_t sw_module;
#ifdef BOOT_RECORD
uint16_t ias_minor;
enum shared_memory_err_t res;
#else
enum boot_status_err_t res;
#endif
switch(sw_info->type) {
case IMG_TYPE_MBL:
sw_module = SW_MBL;
break;
case IMG_TYPE_PROT:
sw_module = SW_PROT;
break;
case IMG_TYPE_AROT:
sw_module = SW_AROT;
break;
case IMG_TYPE_NSPE:
sw_module = SW_NSPE;
break;
default:
sw_module = SW_MAX;
break;
}
#ifdef BOOT_RECORD
/* Add the CBOR encoded boot record to the shared data area. */
ias_minor = SET_IAS_MINOR(sw_module, SW_BOOT_RECORD);
res = mbl_status_tlv_add(TLV_MAJOR_IAS,
ias_minor,
sw_info->record_len,
sw_info->record);
if (res) {
return BOOT_STATUS_ERROR;
}
#else
res = mbl_status_sw_type_add(sw_module);
if (res) {
return res;
}
res = mbl_status_sw_version_add(sw_module, sw_info->version);
if (res) {
return res;
}
res = mbl_status_sw_digest_add(sw_module, sw_info->digest);
if (res) {
return res;
}
res = mbl_status_sw_signer_add(sw_module, sw_info->signer_id);
if (res) {
return res;
}
#endif /* BOOT RECORD */
// print_sw_info(sw_info);
return BOOT_STATUS_OK;
}
/*!
\brief add status boot seed
\param[in] boot_seed: pointer to boot seed
\param[out] none
\retval result of add boot seed
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
enum boot_status_err_t
mbl_status_boot_seed_add(uint8_t *boot_seed)
{
uint16_t ias_minor;
enum shared_memory_err_t res;
ias_minor = SET_IAS_MINOR(SW_GENERAL, BOOT_SEED);
res = mbl_status_tlv_add(TLV_MAJOR_IAS,
ias_minor,
BOOT_SEED_SIZE,
boot_seed);
if (res) {
return BOOT_STATUS_ERROR;
}
return BOOT_STATUS_OK;
}
/*!
\brief add status hardware version
\param[in] hw_version: pointer to boot hardware version
\param[out] none
\retval result of add hardware version
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
enum boot_status_err_t
mbl_status_hw_ver_add(uint8_t *hw_version)
{
uint16_t ias_minor;
enum shared_memory_err_t res;
ias_minor = SET_IAS_MINOR(SW_GENERAL, HW_VERSION);
res = mbl_status_tlv_add(TLV_MAJOR_IAS,
ias_minor,
HW_VERSION_MAX_SIZE,
hw_version);
if (res) {
return BOOT_STATUS_ERROR;
}
return BOOT_STATUS_OK;
}
/*!
\brief add status life cycle
\param[in] life_cycle: life cycle
\param[out] none
\retval result of add life cycle
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
enum boot_status_err_t
mbl_status_life_cycle_add(uint32_t life_cycle)
{
uint16_t ias_minor;
enum shared_memory_err_t res;
ias_minor = SET_IAS_MINOR(SW_GENERAL, SECURITY_LIFECYCLE);
res = mbl_status_tlv_add(TLV_MAJOR_IAS,
ias_minor,
sizeof(uint32_t),
(uint8_t *)&life_cycle);
if (res) {
return BOOT_STATUS_ERROR;
}
return BOOT_STATUS_OK;
}
/*!
\brief add status implement id
\param[in] impl_id: pointer to implement id
\param[out] none
\retval result of add implement id
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
enum boot_status_err_t
mbl_status_impl_id_add(uint8_t *impl_id)
{
uint16_t ias_minor;
enum shared_memory_err_t res;
ias_minor = SET_IAS_MINOR(SW_GENERAL, IMPLEMENTATION_ID);
res = mbl_status_tlv_add(TLV_MAJOR_IAS,
ias_minor,
IMPLEMENTATION_ID_MAX_SIZE,
impl_id);
if (res) {
return BOOT_STATUS_ERROR;
}
return BOOT_STATUS_OK;
}
/*!
\brief add status instance id
\param[in] instance_id: pointer to instance id
\param[out] none
\retval result of add instance id
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
enum boot_status_err_t
mbl_status_inst_id_add(uint8_t *instance_id)
{
uint16_t ias_minor;
enum shared_memory_err_t res;
ias_minor = SET_IAS_MINOR(SW_GENERAL, INSTANCE_ID);
res = mbl_status_tlv_add(TLV_MAJOR_IAS,
ias_minor,
INSTANCE_ID_MAX_SIZE,
instance_id);
if (res) {
return BOOT_STATUS_ERROR;
}
return BOOT_STATUS_OK;
}
/*!
\brief add status running image
\param[in] img_idx: pointer to image index
\param[out] none
\retval result of add image index
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
enum boot_status_err_t
mbl_status_running_img_add(uint8_t *img_idx)
{
uint16_t core_minor;
enum shared_memory_err_t res;
core_minor = SET_CORE_MINOR(SYS_STATUS, STATUS_RUNNING_IMG);
res = mbl_status_tlv_add(TLV_MAJOR_CORE,
core_minor,
4,
img_idx);
if (res) {
return BOOT_STATUS_ERROR;
}
return BOOT_STATUS_OK;
}
/*!
\brief add status sau entry
\param[in] start: pointer to start entry
\param[in] end: pointer to end entry
\param[out] none
\retval result of add sau entry
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
enum boot_status_err_t
mbl_status_sau_entry_add(uint8_t *start, uint8_t *end)
{
uint16_t core_minor;
enum shared_memory_err_t res;
core_minor = SET_CORE_MINOR(SYS_SAU, SAU_ENTRY_START);
res = mbl_status_tlv_add(TLV_MAJOR_CORE,
core_minor,
4,
start);
if (res) {
return BOOT_STATUS_ERROR;
}
core_minor = SET_CORE_MINOR(SYS_SAU, SAU_ENTRY_END);
res = mbl_status_tlv_add(TLV_MAJOR_CORE,
core_minor,
4,
end);
if (res) {
return BOOT_STATUS_ERROR;
}
return BOOT_STATUS_OK;
}
/*!
\brief add status rom version
\param[in] rom_ver: pointer to rom version
\param[out] none
\retval result of add rom version
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
enum boot_status_err_t
mbl_status_rom_version_add(uint8_t *rom_ver)
{
uint16_t core_minor;
enum shared_memory_err_t res;
core_minor = SET_CORE_MINOR(SYS_STATUS, STATUS_ROM_VERSION);
res = mbl_status_tlv_add(TLV_MAJOR_CORE,
core_minor,
4,
rom_ver);
if (res) {
return BOOT_STATUS_ERROR;
}
return BOOT_STATUS_OK;
}
/*!
\brief get status rom version
\param[in] none
\param[out] rom_ver: pointer to rom version
\retval result of add rom version
\arg BOOT_STATUS_OK: boot status ok
\arg BOOT_STATUS_ERROR: boot status error
*/
enum boot_status_err_t
mbl_status_rom_version_get(uint8_t *rom_ver)
{
uint16_t core_minor;
enum shared_memory_err_t res;
uint8_t *tlv_val = NULL;
core_minor = SET_CORE_MINOR(SYS_STATUS, STATUS_ROM_VERSION);
res = (enum shared_memory_err_t) mbl_status_tlv_get(TLV_MAJOR_CORE,
core_minor,
NULL,
&tlv_val);
if (res == 1) {
memcpy(rom_ver, tlv_val, 4);
return BOOT_STATUS_OK;
} else {
memset(rom_ver, 0, 4);
return BOOT_STATUS_ERROR;
}
}
/*!
\brief show status
\param[in] none
\param[out] none
\retval result of show status
*/
int32_t mbl_status_show(void)
{
struct shared_data_tlv_entry tlv_entry;
struct tfm_boot_data *boot_data;
uint8_t *tlv_end;
uint8_t *tlv_curr;
uint16_t i;
boot_data = (struct tfm_boot_data *)MBL_SHARED_DATA_START;
if (boot_data->header.tlv_magic != SHARED_DATA_TLV_INFO_MAGIC) {
return -1;
}
/* Get the boundaries of TLV section where to lookup*/
tlv_end = (uint8_t *)boot_data + boot_data->header.tlv_tot_len;
/* Iterates over the TLV section */
rom_printf("MBL Status Show:\r\n================================\r\n");
rom_printf("Magic: %04x\r\n", boot_data->header.tlv_magic);
rom_printf("Total length: 0x%04x\r\n", boot_data->header.tlv_tot_len);
tlv_curr = boot_data->data;
rom_printf("T\tL\tV\r\n");
for (; tlv_curr < tlv_end; tlv_curr += tlv_entry.tlv_len) {
/* Create local copy to avoid unaligned access */
memcpy(&tlv_entry, tlv_curr, SHARED_DATA_ENTRY_HEADER_SIZE);
rom_printf("%04x\t%04x\t", tlv_entry.tlv_type, tlv_entry.tlv_len);
i = SHARED_DATA_ENTRY_HEADER_SIZE;
for (; i < tlv_entry.tlv_len; i++) {
if (i == tlv_entry.tlv_len -1)
rom_printf("%02x", tlv_curr[i]);
else
rom_printf("%02x-", tlv_curr[i]);
}
rom_printf("\r\n");
}
return 0;
}
/*!
\brief dump status
\param[in] none
\param[out] none
\retval result of dump status
*/
int32_t mbl_status_dump(void)
{
struct tfm_boot_data *boot_data;
uint8_t *p;
boot_data = (struct tfm_boot_data *)MBL_SHARED_DATA_START;
p = (uint8_t *)boot_data;
rom_printf("MBL Status Dump:\r\n================================\r\n");
print_data(p, boot_data->header.tlv_tot_len);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink