268 lines
7.9 KiB
C
Executable File
268 lines
7.9 KiB
C
Executable File
// Copyright 2020-2022 Beken
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#ifndef __MON_CALL_H__
|
|
#define __MON_CALL_H__
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif /* __cplusplus */
|
|
|
|
#include <common/bk_typedef.h>
|
|
|
|
#define OTP_USER_ID_START 32
|
|
#define OTP_SEG_ID_MAX 0xEF
|
|
#define OTP_SEG_MAX_BYTE 1000
|
|
#define OTP_SEG_MAX_WORD (OTP_SEG_MAX_BYTE / 4)
|
|
|
|
#define OTP_R_ON 0x01 /* read enable. */
|
|
#define OTP_W_ON 0x02 /* write enable. */
|
|
#define OTP_PERM_MASK 0x03
|
|
#define OTP_PERM_BITS 0x02 /* 2-bits for every app. */
|
|
|
|
enum
|
|
{
|
|
OTP_OK = 0,
|
|
OTP_ID_ERROR, /* ID not in the range of 0 ~ OTP_SEG_ID_MAX. */
|
|
OTP_LEN_ERROR, /* request size to be read/written is not the same with OTP data. */
|
|
OTP_ALIGN_ERROR, /* buffer address is not aligned with 4 bytes. */
|
|
OTP_PERMISSION_ERROR, /* no permission to read or write. */
|
|
OTP_EXISTED_ERROR, /* the OTP data specified by id is exited when try to create */
|
|
OTP_NOT_EXISTED_ERROR, /* the OTP data specified by id is not exited when try to read/write. */
|
|
OTP_NO_SPACE_ERROR, /* no free space when try to create new OTP data. */
|
|
OTP_WRITE_ERROR, /* try to write 1 to OTP bit which was in 0 state. */
|
|
};
|
|
|
|
enum
|
|
{
|
|
ENCLV_ID_BOOTLDR = 0,
|
|
ENCLV_ID_APP,
|
|
};
|
|
|
|
#define PMP_X_ON 4
|
|
#define PMP_W_ON 2
|
|
#define PMP_R_ON 1
|
|
#define PMP_XWR_ON (PMP_X_ON | PMP_W_ON | PMP_R_ON)
|
|
#define PMP_XWR_MASK (PMP_X_ON | PMP_W_ON | PMP_R_ON)
|
|
|
|
/**
|
|
* @brief FreeRTOS yield porting API
|
|
*
|
|
* This API is used for FreRTOS task switch by issue the ecall instruction:
|
|
*
|
|
* @param
|
|
* - void
|
|
*
|
|
* @attention Used for FreeRTOS porting only.
|
|
*
|
|
* @return
|
|
* - void
|
|
*/
|
|
void mon_task_yield(void);
|
|
|
|
/**
|
|
* @brief clear U-Timer interrupt.
|
|
*
|
|
* This API is used to clear U mode Timer interrupt.
|
|
*
|
|
* @param
|
|
* - void
|
|
*
|
|
* @attention
|
|
*
|
|
* @return
|
|
* - void
|
|
*/
|
|
void mon_timer_int_clear(void);
|
|
|
|
/**
|
|
* @brief Start/Stop CPU1
|
|
*
|
|
* This API is used for FreRTOS task switch by issue the ecall instruction:
|
|
* - Uses CPU poll wait to do delay, so it blocks CPU.
|
|
* - The caller should confirm the specifies GPIO is not used by other APP.
|
|
*
|
|
* @param
|
|
* - enable: 0: stop CPU1, otherwise start CPU1.
|
|
* @param
|
|
* - start_addr: start addess where CPU1 will run from when it is to start CPU1,
|
|
* it is not care if it is to stop CPU1.
|
|
*
|
|
* @attention
|
|
* - this function will damage the last 2 bytes of the Shared Memory
|
|
* to save the start_addr temporarily.
|
|
*
|
|
* @return
|
|
* - void
|
|
*/
|
|
void mon_reset_cpu1(u32 enable, u32 start_addr);
|
|
|
|
/**
|
|
* @brief Flush all data cache
|
|
*
|
|
* This API will flush the WHOLE data cache if the memory specified by 'addr' is in the cacheable region.
|
|
*
|
|
* @param addr the memory address intended to be flush.
|
|
*
|
|
* @attention it is not efficient to call this API if just want to flush one or two cache lines.
|
|
* it is 32 byte per cache line in BK7256/BK7235.
|
|
*
|
|
* @return
|
|
* - void
|
|
*/
|
|
void mon_flush_dcache(u32 addr);
|
|
|
|
/**
|
|
* @brief get chache line size
|
|
*
|
|
* @param
|
|
* - void
|
|
*
|
|
* @return
|
|
* - bytes per cache line.
|
|
*/
|
|
u32 mon_get_dcache_linesize(void);
|
|
|
|
// extern void mon_set_stack_limit(u32 statc_max_addr, u32 stack_min_addr, u32 sp);
|
|
|
|
/**
|
|
* @brief switched from bootloader to Application.
|
|
*
|
|
* This API is used by bootloader to jump to Application code.
|
|
*
|
|
* @param *entry entry addres of Application code.
|
|
*
|
|
* @attention Application can NOT call this API.
|
|
*
|
|
* @return
|
|
* - void
|
|
*/
|
|
void mon_bl_2_app(void *entry);
|
|
|
|
/**
|
|
* @brief notify Monitor that U-mode code starts ok.
|
|
*
|
|
* This API is used by U-mode code to notify Monitor that it can handle interrupts,
|
|
* so the interrupts will be sent to U-mode after this API returns .
|
|
*
|
|
* @param
|
|
* - void
|
|
*
|
|
* @attention U-mode code must call this API as soon as it startup (can handle interrupts by U-mode itself).
|
|
*
|
|
* @return
|
|
* - 0: succeed
|
|
* - this API always returns 0.
|
|
*/
|
|
u32 mon_app_started(void);
|
|
|
|
/**
|
|
* @brief read OTP data specified by data id.
|
|
*
|
|
* This API is to read OTP data specified by the id.
|
|
*
|
|
* @param *buf buffer to receive OTP data, its size MUST be >= the OPT data size.
|
|
* @param data_id 0 ~ OTP_SEG_ID_MAX.
|
|
* @param len bytes request to read, it ** MUST ** be the data size already created in the OTP.
|
|
*
|
|
* @attention The buf must be aligned with 4 bytes,
|
|
* otherwise the error code OTP_ALIGN_ERROR will be returned.
|
|
*
|
|
* @return
|
|
* - OTP_OK: succeed
|
|
* - others: error code.
|
|
*/
|
|
u32 mon_read_otp(u32 *buf, u32 data_id, u32 len);
|
|
|
|
/**
|
|
* @brief write OTP data specified by data id. data segment must have the 'write' attribute.
|
|
*
|
|
* This API is to write OTP data specified by the id.
|
|
*
|
|
* @param data_id 0 ~ OTP_SEG_ID_MAX.
|
|
* @param *buf buffer contained OTP data
|
|
* @param len bytes need be written, it is the size of the OTP data created before.
|
|
*
|
|
* @attention The buf must be aligned with 4 bytes,
|
|
* otherwise the error code OTP_ALIGN_ERROR will be returned.
|
|
*
|
|
* @return
|
|
* - OTP_OK: succeed
|
|
* - others: error code.
|
|
*/
|
|
u32 mon_write_otp(u32 data_id, u32 *buf, u32 len);
|
|
|
|
/**
|
|
* @brief Create OTP data segment
|
|
*
|
|
* This API is to create an OTP data segment with the specified id.
|
|
*
|
|
* @param data_id OTP_USER_ID_START ~ OTP_SEG_ID_MAX.
|
|
* @param *buf buffer contained OTP data
|
|
* @param len bytes need be written, it is the size of the OTP data to be created. ( 1 ~ OTP_SEG_MAX_BYTE inclusive)
|
|
* @param attr attributes of the data segment. it sets the R/W attributes for every ENCLAVE (bootloader / application)
|
|
* bit 0 is the Read permission for bootloader, bit 1 is the Write permission for bootloader.
|
|
* bit 2 is the Read permission for Application, bit 3 is the Write permission for Application.
|
|
* bit 4~7 are reserved, must be set to 0.
|
|
*
|
|
* @attention The buf must be aligned with 4 bytes,
|
|
* otherwise the error code OTP_ALIGN_ERROR will be returned.
|
|
* data_id must be in range from OTP_USER_ID_START to OTP_SEG_ID_MAX (inclusive) for this API.
|
|
*
|
|
* @return
|
|
* - OTP_OK: succeed
|
|
* - others: error code.
|
|
*/
|
|
u32 mon_create_otp(u32 data_id, u32 *buf, u32 len, u32 attr);
|
|
|
|
/**
|
|
* @brief set PMP protection setting
|
|
*
|
|
* This API is used to set the memory protection for the specified range (start_addr & size) with the attributes.
|
|
*
|
|
* @param start_addr start address of the protection range, MUST be aligned with 32 bytes..
|
|
* @param size size of the protection range, MUST be >= 32 bytes, and must be multiple of 32 bytes.
|
|
* @param attr execution (PMP_X_ON), write (PMP_W_ON), read (PMP_R_ON). can be any combinations of the 3 attributes.
|
|
*
|
|
* @attention this API may use 1~2 entries for one setting, relies on the alignment of the start address and the size of the range.
|
|
*
|
|
* @return
|
|
* - 0: succeed
|
|
* - 1: no free config entry for the setting.
|
|
*/
|
|
u32 mon_pmp_cfg(u32 start_addr, u32 size, u8 attr);
|
|
|
|
/**
|
|
* @brief get numbers of free memory protection config entry.
|
|
*
|
|
* This API returns number of unused PMP config entries.
|
|
* U-mode code can use the free cfg entries to protect range of the addres space.
|
|
* - The caller should confirm the specifies GPIO is not used by other APP.
|
|
*
|
|
* @param *free_cnt receives the free config entries.
|
|
*
|
|
* @return
|
|
* - 0: succeed, this API always return 0.
|
|
*/
|
|
u32 mon_get_free_pmp_cfg(u8 *free_cnt);
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* __cplusplus */
|
|
|
|
|
|
#endif /* __MON_CALL_H__ */
|
|
|